ALIS  0.0.5
Develop the video games of your dreams.
ImGui.cs
1 // --------------------------------------------------------------------------
2 //
3 // █▀▀█ ░█─── ▀█▀ ░█▀▀▀█
4 // ░█▄▄█ ░█─── ░█─ ─▀▀▀▄▄
5 // ░█─░█ ░█▄▄█ ▄█▄ ░█▄▄▄█
6 //
7 // --------------------------------------------------------------------------
8 // File:ImGui.cs
9 //
10 // Author:Pablo Perdomo Falcón
11 // Web:https://www.pabllopf.dev/
12 //
13 // Copyright (c) 2021 GNU General Public License v3.0
14 //
15 // This program is free software:you can redistribute it and/or modify
16 // it under the terms of the GNU General Public License as published by
17 // the Free Software Foundation, either version 3 of the License, or
18 // (at your option) any later version.
19 //
20 // This program is distributed in the hope that it will be useful,
21 // but WITHOUT ANY WARRANTY without even the implied warranty of
22 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
23 // GNU General Public License for more details.
24 //
25 // You should have received a copy of the GNU General Public License
26 // along with this program.If not, see <http://www.gnu.org/licenses/>.
27 //
28 // --------------------------------------------------------------------------
29 
30 using System;
31 using System.Runtime.InteropServices;
32 using System.Text;
33 using Alis.Core.Aspect.Math.Vector;
34 using Alis.Core.Graphic.ImGui.Delegates;
35 using Alis.Core.Graphic.ImGui.Enums;
36 using Alis.Core.Graphic.ImGui.Structs;
37 using Alis.Core.Graphic.ImGui.Utils;
38 
39 namespace Alis.Core.Graphic.ImGui
40 {
44  public static unsafe class ImGui
45  {
51  public static ImGuiPayloadPtr AcceptDragDropPayload(string type)
52  {
53  byte* nativeType;
54  int typeByteCount = 0;
55  if (type != null)
56  {
57  typeByteCount = Encoding.UTF8.GetByteCount(type);
58  if (typeByteCount > Util.StackAllocationSizeLimit)
59  {
60  nativeType = Util.Allocate(typeByteCount + 1);
61  }
62  else
63  {
64  byte* nativeTypeStackBytes = stackalloc byte[typeByteCount + 1];
65  nativeType = nativeTypeStackBytes;
66  }
67 
68  int nativeTypeOffset = Util.GetUtf8(type, nativeType, typeByteCount);
69  nativeType[nativeTypeOffset] = 0;
70  }
71  else
72  {
73  nativeType = null;
74  }
75 
76  ImGuiDragDropFlags flags = 0;
77  ImGuiPayload* ret = ImGuiNative.igAcceptDragDropPayload(nativeType, flags);
78  if (typeByteCount > Util.StackAllocationSizeLimit)
79  {
80  Util.Free(nativeType);
81  }
82 
83  return new ImGuiPayloadPtr(ret);
84  }
85 
92  public static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDropFlags flags)
93  {
94  byte* nativeType;
95  int typeByteCount = 0;
96  if (type != null)
97  {
98  typeByteCount = Encoding.UTF8.GetByteCount(type);
99  if (typeByteCount > Util.StackAllocationSizeLimit)
100  {
101  nativeType = Util.Allocate(typeByteCount + 1);
102  }
103  else
104  {
105  byte* nativeTypeStackBytes = stackalloc byte[typeByteCount + 1];
106  nativeType = nativeTypeStackBytes;
107  }
108 
109  int nativeTypeOffset = Util.GetUtf8(type, nativeType, typeByteCount);
110  nativeType[nativeTypeOffset] = 0;
111  }
112  else
113  {
114  nativeType = null;
115  }
116 
117  ImGuiPayload* ret = ImGuiNative.igAcceptDragDropPayload(nativeType, flags);
118  if (typeByteCount > Util.StackAllocationSizeLimit)
119  {
120  Util.Free(nativeType);
121  }
122 
123  return new ImGuiPayloadPtr(ret);
124  }
125 
129  public static void AlignTextToFramePadding()
130  {
131  ImGuiNative.igAlignTextToFramePadding();
132  }
133 
140  public static bool ArrowButton(string strId, ImGuiDir dir)
141  {
142  byte* nativeStrId;
143  int strIdByteCount = 0;
144  if (strId != null)
145  {
146  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
147  if (strIdByteCount > Util.StackAllocationSizeLimit)
148  {
149  nativeStrId = Util.Allocate(strIdByteCount + 1);
150  }
151  else
152  {
153  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
154  nativeStrId = nativeStrIdStackBytes;
155  }
156 
157  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
158  nativeStrId[nativeStrIdOffset] = 0;
159  }
160  else
161  {
162  nativeStrId = null;
163  }
164 
165  byte ret = ImGuiNative.igArrowButton(nativeStrId, dir);
166  if (strIdByteCount > Util.StackAllocationSizeLimit)
167  {
168  Util.Free(nativeStrId);
169  }
170 
171  return ret != 0;
172  }
173 
179  public static bool Begin(string name)
180  {
181  byte* nativeName;
182  int nameByteCount = 0;
183  if (name != null)
184  {
185  nameByteCount = Encoding.UTF8.GetByteCount(name);
186  if (nameByteCount > Util.StackAllocationSizeLimit)
187  {
188  nativeName = Util.Allocate(nameByteCount + 1);
189  }
190  else
191  {
192  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
193  nativeName = nativeNameStackBytes;
194  }
195 
196  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
197  nativeName[nativeNameOffset] = 0;
198  }
199  else
200  {
201  nativeName = null;
202  }
203 
204  byte* pOpen = null;
205  ImGuiWindowFlags flags = 0;
206  byte ret = ImGuiNative.igBegin(nativeName, pOpen, flags);
207  if (nameByteCount > Util.StackAllocationSizeLimit)
208  {
209  Util.Free(nativeName);
210  }
211 
212  return ret != 0;
213  }
214 
221  public static bool Begin(string name, ref bool pOpen)
222  {
223  byte* nativeName;
224  int nameByteCount = 0;
225  if (name != null)
226  {
227  nameByteCount = Encoding.UTF8.GetByteCount(name);
228  if (nameByteCount > Util.StackAllocationSizeLimit)
229  {
230  nativeName = Util.Allocate(nameByteCount + 1);
231  }
232  else
233  {
234  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
235  nativeName = nativeNameStackBytes;
236  }
237 
238  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
239  nativeName[nativeNameOffset] = 0;
240  }
241  else
242  {
243  nativeName = null;
244  }
245 
246  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
247  byte* nativePOpen = &nativePOpenVal;
248  ImGuiWindowFlags flags = 0;
249  byte ret = ImGuiNative.igBegin(nativeName, nativePOpen, flags);
250  if (nameByteCount > Util.StackAllocationSizeLimit)
251  {
252  Util.Free(nativeName);
253  }
254 
255  pOpen = nativePOpenVal != 0;
256  return ret != 0;
257  }
258 
266  public static bool Begin(string name, ref bool pOpen, ImGuiWindowFlags flags)
267  {
268  byte* nativeName;
269  int nameByteCount = 0;
270  if (name != null)
271  {
272  nameByteCount = Encoding.UTF8.GetByteCount(name);
273  if (nameByteCount > Util.StackAllocationSizeLimit)
274  {
275  nativeName = Util.Allocate(nameByteCount + 1);
276  }
277  else
278  {
279  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
280  nativeName = nativeNameStackBytes;
281  }
282 
283  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
284  nativeName[nativeNameOffset] = 0;
285  }
286  else
287  {
288  nativeName = null;
289  }
290 
291  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
292  byte* nativePOpen = &nativePOpenVal;
293  byte ret = ImGuiNative.igBegin(nativeName, nativePOpen, flags);
294  if (nameByteCount > Util.StackAllocationSizeLimit)
295  {
296  Util.Free(nativeName);
297  }
298 
299  pOpen = nativePOpenVal != 0;
300  return ret != 0;
301  }
302 
308  public static bool BeginChild(string strId)
309  {
310  byte* nativeStrId;
311  int strIdByteCount = 0;
312  if (strId != null)
313  {
314  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
315  if (strIdByteCount > Util.StackAllocationSizeLimit)
316  {
317  nativeStrId = Util.Allocate(strIdByteCount + 1);
318  }
319  else
320  {
321  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
322  nativeStrId = nativeStrIdStackBytes;
323  }
324 
325  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
326  nativeStrId[nativeStrIdOffset] = 0;
327  }
328  else
329  {
330  nativeStrId = null;
331  }
332 
333  Vector2F size = new Vector2F();
334  byte border = 0;
335  ImGuiWindowFlags flags = 0;
336  byte ret = ImGuiNative.igBeginChild_Str(nativeStrId, size, border, flags);
337  if (strIdByteCount > Util.StackAllocationSizeLimit)
338  {
339  Util.Free(nativeStrId);
340  }
341 
342  return ret != 0;
343  }
344 
351  public static bool BeginChild(string strId, Vector2F size)
352  {
353  byte* nativeStrId;
354  int strIdByteCount = 0;
355  if (strId != null)
356  {
357  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
358  if (strIdByteCount > Util.StackAllocationSizeLimit)
359  {
360  nativeStrId = Util.Allocate(strIdByteCount + 1);
361  }
362  else
363  {
364  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
365  nativeStrId = nativeStrIdStackBytes;
366  }
367 
368  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
369  nativeStrId[nativeStrIdOffset] = 0;
370  }
371  else
372  {
373  nativeStrId = null;
374  }
375 
376  byte border = 0;
377  ImGuiWindowFlags flags = 0;
378  byte ret = ImGuiNative.igBeginChild_Str(nativeStrId, size, border, flags);
379  if (strIdByteCount > Util.StackAllocationSizeLimit)
380  {
381  Util.Free(nativeStrId);
382  }
383 
384  return ret != 0;
385  }
386 
394  public static bool BeginChild(string strId, Vector2F size, bool border)
395  {
396  byte* nativeStrId;
397  int strIdByteCount = 0;
398  if (strId != null)
399  {
400  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
401  if (strIdByteCount > Util.StackAllocationSizeLimit)
402  {
403  nativeStrId = Util.Allocate(strIdByteCount + 1);
404  }
405  else
406  {
407  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
408  nativeStrId = nativeStrIdStackBytes;
409  }
410 
411  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
412  nativeStrId[nativeStrIdOffset] = 0;
413  }
414  else
415  {
416  nativeStrId = null;
417  }
418 
419  byte nativeBorder = border ? (byte) 1 : (byte) 0;
420  ImGuiWindowFlags flags = 0;
421  byte ret = ImGuiNative.igBeginChild_Str(nativeStrId, size, nativeBorder, flags);
422  if (strIdByteCount > Util.StackAllocationSizeLimit)
423  {
424  Util.Free(nativeStrId);
425  }
426 
427  return ret != 0;
428  }
429 
438  public static bool BeginChild(string strId, Vector2F size, bool border, ImGuiWindowFlags flags)
439  {
440  byte* nativeStrId;
441  int strIdByteCount = 0;
442  if (strId != null)
443  {
444  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
445  if (strIdByteCount > Util.StackAllocationSizeLimit)
446  {
447  nativeStrId = Util.Allocate(strIdByteCount + 1);
448  }
449  else
450  {
451  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
452  nativeStrId = nativeStrIdStackBytes;
453  }
454 
455  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
456  nativeStrId[nativeStrIdOffset] = 0;
457  }
458  else
459  {
460  nativeStrId = null;
461  }
462 
463  byte nativeBorder = border ? (byte) 1 : (byte) 0;
464  byte ret = ImGuiNative.igBeginChild_Str(nativeStrId, size, nativeBorder, flags);
465  if (strIdByteCount > Util.StackAllocationSizeLimit)
466  {
467  Util.Free(nativeStrId);
468  }
469 
470  return ret != 0;
471  }
472 
478  public static bool BeginChild(uint id)
479  {
480  Vector2F size = new Vector2F();
481  byte border = 0;
482  ImGuiWindowFlags flags = 0;
483  byte ret = ImGuiNative.igBeginChild_ID(id, size, border, flags);
484  return ret != 0;
485  }
486 
493  public static bool BeginChild(uint id, Vector2F size)
494  {
495  byte border = 0;
496  ImGuiWindowFlags flags = 0;
497  byte ret = ImGuiNative.igBeginChild_ID(id, size, border, flags);
498  return ret != 0;
499  }
500 
508  public static bool BeginChild(uint id, Vector2F size, bool border)
509  {
510  byte nativeBorder = border ? (byte) 1 : (byte) 0;
511  ImGuiWindowFlags flags = 0;
512  byte ret = ImGuiNative.igBeginChild_ID(id, size, nativeBorder, flags);
513  return ret != 0;
514  }
515 
524  public static bool BeginChild(uint id, Vector2F size, bool border, ImGuiWindowFlags flags)
525  {
526  byte nativeBorder = border ? (byte) 1 : (byte) 0;
527  byte ret = ImGuiNative.igBeginChild_ID(id, size, nativeBorder, flags);
528  return ret != 0;
529  }
530 
537  public static bool BeginChildFrame(uint id, Vector2F size)
538  {
539  ImGuiWindowFlags flags = 0;
540  byte ret = ImGuiNative.igBeginChildFrame(id, size, flags);
541  return ret != 0;
542  }
543 
551  public static bool BeginChildFrame(uint id, Vector2F size, ImGuiWindowFlags flags)
552  {
553  byte ret = ImGuiNative.igBeginChildFrame(id, size, flags);
554  return ret != 0;
555  }
556 
563  public static bool BeginCombo(string label, string previewValue)
564  {
565  byte* nativeLabel;
566  int labelByteCount = 0;
567  if (label != null)
568  {
569  labelByteCount = Encoding.UTF8.GetByteCount(label);
570  if (labelByteCount > Util.StackAllocationSizeLimit)
571  {
572  nativeLabel = Util.Allocate(labelByteCount + 1);
573  }
574  else
575  {
576  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
577  nativeLabel = nativeLabelStackBytes;
578  }
579 
580  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
581  nativeLabel[nativeLabelOffset] = 0;
582  }
583  else
584  {
585  nativeLabel = null;
586  }
587 
588  byte* nativePreviewValue;
589  int previewValueByteCount = 0;
590  if (previewValue != null)
591  {
592  previewValueByteCount = Encoding.UTF8.GetByteCount(previewValue);
593  if (previewValueByteCount > Util.StackAllocationSizeLimit)
594  {
595  nativePreviewValue = Util.Allocate(previewValueByteCount + 1);
596  }
597  else
598  {
599  byte* nativePreviewValueStackBytes = stackalloc byte[previewValueByteCount + 1];
600  nativePreviewValue = nativePreviewValueStackBytes;
601  }
602 
603  int nativePreviewValueOffset = Util.GetUtf8(previewValue, nativePreviewValue, previewValueByteCount);
604  nativePreviewValue[nativePreviewValueOffset] = 0;
605  }
606  else
607  {
608  nativePreviewValue = null;
609  }
610 
611  ImGuiComboFlags flags = 0;
612  byte ret = ImGuiNative.igBeginCombo(nativeLabel, nativePreviewValue, flags);
613  if (labelByteCount > Util.StackAllocationSizeLimit)
614  {
615  Util.Free(nativeLabel);
616  }
617 
618  if (previewValueByteCount > Util.StackAllocationSizeLimit)
619  {
620  Util.Free(nativePreviewValue);
621  }
622 
623  return ret != 0;
624  }
625 
633  public static bool BeginCombo(string label, string previewValue, ImGuiComboFlags flags)
634  {
635  byte* nativeLabel;
636  int labelByteCount = 0;
637  if (label != null)
638  {
639  labelByteCount = Encoding.UTF8.GetByteCount(label);
640  if (labelByteCount > Util.StackAllocationSizeLimit)
641  {
642  nativeLabel = Util.Allocate(labelByteCount + 1);
643  }
644  else
645  {
646  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
647  nativeLabel = nativeLabelStackBytes;
648  }
649 
650  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
651  nativeLabel[nativeLabelOffset] = 0;
652  }
653  else
654  {
655  nativeLabel = null;
656  }
657 
658  byte* nativePreviewValue;
659  int previewValueByteCount = 0;
660  if (previewValue != null)
661  {
662  previewValueByteCount = Encoding.UTF8.GetByteCount(previewValue);
663  if (previewValueByteCount > Util.StackAllocationSizeLimit)
664  {
665  nativePreviewValue = Util.Allocate(previewValueByteCount + 1);
666  }
667  else
668  {
669  byte* nativePreviewValueStackBytes = stackalloc byte[previewValueByteCount + 1];
670  nativePreviewValue = nativePreviewValueStackBytes;
671  }
672 
673  int nativePreviewValueOffset = Util.GetUtf8(previewValue, nativePreviewValue, previewValueByteCount);
674  nativePreviewValue[nativePreviewValueOffset] = 0;
675  }
676  else
677  {
678  nativePreviewValue = null;
679  }
680 
681  byte ret = ImGuiNative.igBeginCombo(nativeLabel, nativePreviewValue, flags);
682  if (labelByteCount > Util.StackAllocationSizeLimit)
683  {
684  Util.Free(nativeLabel);
685  }
686 
687  if (previewValueByteCount > Util.StackAllocationSizeLimit)
688  {
689  Util.Free(nativePreviewValue);
690  }
691 
692  return ret != 0;
693  }
694 
698  public static void BeginDisabled()
699  {
700  byte disabled = 1;
701  ImGuiNative.igBeginDisabled(disabled);
702  }
703 
708  public static void BeginDisabled(bool disabled)
709  {
710  byte nativeDisabled = disabled ? (byte) 1 : (byte) 0;
711  ImGuiNative.igBeginDisabled(nativeDisabled);
712  }
713 
718  public static bool BeginDragDropSource()
719  {
720  ImGuiDragDropFlags flags = 0;
721  byte ret = ImGuiNative.igBeginDragDropSource(flags);
722  return ret != 0;
723  }
724 
730  public static bool BeginDragDropSource(ImGuiDragDropFlags flags)
731  {
732  byte ret = ImGuiNative.igBeginDragDropSource(flags);
733  return ret != 0;
734  }
735 
740  public static bool BeginDragDropTarget()
741  {
742  byte ret = ImGuiNative.igBeginDragDropTarget();
743  return ret != 0;
744  }
745 
749  public static void BeginGroup()
750  {
751  ImGuiNative.igBeginGroup();
752  }
753 
759  public static bool BeginListBox(string label)
760  {
761  byte* nativeLabel;
762  int labelByteCount = 0;
763  if (label != null)
764  {
765  labelByteCount = Encoding.UTF8.GetByteCount(label);
766  if (labelByteCount > Util.StackAllocationSizeLimit)
767  {
768  nativeLabel = Util.Allocate(labelByteCount + 1);
769  }
770  else
771  {
772  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
773  nativeLabel = nativeLabelStackBytes;
774  }
775 
776  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
777  nativeLabel[nativeLabelOffset] = 0;
778  }
779  else
780  {
781  nativeLabel = null;
782  }
783 
784  Vector2F size = new Vector2F();
785  byte ret = ImGuiNative.igBeginListBox(nativeLabel, size);
786  if (labelByteCount > Util.StackAllocationSizeLimit)
787  {
788  Util.Free(nativeLabel);
789  }
790 
791  return ret != 0;
792  }
793 
800  public static bool BeginListBox(string label, Vector2F size)
801  {
802  byte* nativeLabel;
803  int labelByteCount = 0;
804  if (label != null)
805  {
806  labelByteCount = Encoding.UTF8.GetByteCount(label);
807  if (labelByteCount > Util.StackAllocationSizeLimit)
808  {
809  nativeLabel = Util.Allocate(labelByteCount + 1);
810  }
811  else
812  {
813  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
814  nativeLabel = nativeLabelStackBytes;
815  }
816 
817  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
818  nativeLabel[nativeLabelOffset] = 0;
819  }
820  else
821  {
822  nativeLabel = null;
823  }
824 
825  byte ret = ImGuiNative.igBeginListBox(nativeLabel, size);
826  if (labelByteCount > Util.StackAllocationSizeLimit)
827  {
828  Util.Free(nativeLabel);
829  }
830 
831  return ret != 0;
832  }
833 
838  public static bool BeginMainMenuBar()
839  {
840  byte ret = ImGuiNative.igBeginMainMenuBar();
841  return ret != 0;
842  }
843 
849  public static bool BeginMenu(string label)
850  {
851  byte* nativeLabel;
852  int labelByteCount = 0;
853  if (label != null)
854  {
855  labelByteCount = Encoding.UTF8.GetByteCount(label);
856  if (labelByteCount > Util.StackAllocationSizeLimit)
857  {
858  nativeLabel = Util.Allocate(labelByteCount + 1);
859  }
860  else
861  {
862  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
863  nativeLabel = nativeLabelStackBytes;
864  }
865 
866  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
867  nativeLabel[nativeLabelOffset] = 0;
868  }
869  else
870  {
871  nativeLabel = null;
872  }
873 
874  byte enabled = 1;
875  byte ret = ImGuiNative.igBeginMenu(nativeLabel, enabled);
876  if (labelByteCount > Util.StackAllocationSizeLimit)
877  {
878  Util.Free(nativeLabel);
879  }
880 
881  return ret != 0;
882  }
883 
890  public static bool BeginMenu(string label, bool enabled)
891  {
892  byte* nativeLabel;
893  int labelByteCount = 0;
894  if (label != null)
895  {
896  labelByteCount = Encoding.UTF8.GetByteCount(label);
897  if (labelByteCount > Util.StackAllocationSizeLimit)
898  {
899  nativeLabel = Util.Allocate(labelByteCount + 1);
900  }
901  else
902  {
903  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
904  nativeLabel = nativeLabelStackBytes;
905  }
906 
907  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
908  nativeLabel[nativeLabelOffset] = 0;
909  }
910  else
911  {
912  nativeLabel = null;
913  }
914 
915  byte nativeEnabled = enabled ? (byte) 1 : (byte) 0;
916  byte ret = ImGuiNative.igBeginMenu(nativeLabel, nativeEnabled);
917  if (labelByteCount > Util.StackAllocationSizeLimit)
918  {
919  Util.Free(nativeLabel);
920  }
921 
922  return ret != 0;
923  }
924 
929  public static bool BeginMenuBar()
930  {
931  byte ret = ImGuiNative.igBeginMenuBar();
932  return ret != 0;
933  }
934 
940  public static bool BeginPopup(string strId)
941  {
942  byte* nativeStrId;
943  int strIdByteCount = 0;
944  if (strId != null)
945  {
946  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
947  if (strIdByteCount > Util.StackAllocationSizeLimit)
948  {
949  nativeStrId = Util.Allocate(strIdByteCount + 1);
950  }
951  else
952  {
953  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
954  nativeStrId = nativeStrIdStackBytes;
955  }
956 
957  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
958  nativeStrId[nativeStrIdOffset] = 0;
959  }
960  else
961  {
962  nativeStrId = null;
963  }
964 
965  ImGuiWindowFlags flags = 0;
966  byte ret = ImGuiNative.igBeginPopup(nativeStrId, flags);
967  if (strIdByteCount > Util.StackAllocationSizeLimit)
968  {
969  Util.Free(nativeStrId);
970  }
971 
972  return ret != 0;
973  }
974 
981  public static bool BeginPopup(string strId, ImGuiWindowFlags flags)
982  {
983  byte* nativeStrId;
984  int strIdByteCount = 0;
985  if (strId != null)
986  {
987  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
988  if (strIdByteCount > Util.StackAllocationSizeLimit)
989  {
990  nativeStrId = Util.Allocate(strIdByteCount + 1);
991  }
992  else
993  {
994  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
995  nativeStrId = nativeStrIdStackBytes;
996  }
997 
998  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
999  nativeStrId[nativeStrIdOffset] = 0;
1000  }
1001  else
1002  {
1003  nativeStrId = null;
1004  }
1005 
1006  byte ret = ImGuiNative.igBeginPopup(nativeStrId, flags);
1007  if (strIdByteCount > Util.StackAllocationSizeLimit)
1008  {
1009  Util.Free(nativeStrId);
1010  }
1011 
1012  return ret != 0;
1013  }
1014 
1019  public static bool BeginPopupContextItem()
1020  {
1021  byte* nativeStrId = null;
1022  ImGuiPopupFlags popupFlags = (ImGuiPopupFlags) 1;
1023  byte ret = ImGuiNative.igBeginPopupContextItem(nativeStrId, popupFlags);
1024  return ret != 0;
1025  }
1026 
1032  public static bool BeginPopupContextItem(string strId)
1033  {
1034  byte* nativeStrId;
1035  int strIdByteCount = 0;
1036  if (strId != null)
1037  {
1038  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1039  if (strIdByteCount > Util.StackAllocationSizeLimit)
1040  {
1041  nativeStrId = Util.Allocate(strIdByteCount + 1);
1042  }
1043  else
1044  {
1045  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1046  nativeStrId = nativeStrIdStackBytes;
1047  }
1048 
1049  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1050  nativeStrId[nativeStrIdOffset] = 0;
1051  }
1052  else
1053  {
1054  nativeStrId = null;
1055  }
1056 
1057  ImGuiPopupFlags popupFlags = (ImGuiPopupFlags) 1;
1058  byte ret = ImGuiNative.igBeginPopupContextItem(nativeStrId, popupFlags);
1059  if (strIdByteCount > Util.StackAllocationSizeLimit)
1060  {
1061  Util.Free(nativeStrId);
1062  }
1063 
1064  return ret != 0;
1065  }
1066 
1073  public static bool BeginPopupContextItem(string strId, ImGuiPopupFlags popupFlags)
1074  {
1075  byte* nativeStrId;
1076  int strIdByteCount = 0;
1077  if (strId != null)
1078  {
1079  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1080  if (strIdByteCount > Util.StackAllocationSizeLimit)
1081  {
1082  nativeStrId = Util.Allocate(strIdByteCount + 1);
1083  }
1084  else
1085  {
1086  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1087  nativeStrId = nativeStrIdStackBytes;
1088  }
1089 
1090  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1091  nativeStrId[nativeStrIdOffset] = 0;
1092  }
1093  else
1094  {
1095  nativeStrId = null;
1096  }
1097 
1098  byte ret = ImGuiNative.igBeginPopupContextItem(nativeStrId, popupFlags);
1099  if (strIdByteCount > Util.StackAllocationSizeLimit)
1100  {
1101  Util.Free(nativeStrId);
1102  }
1103 
1104  return ret != 0;
1105  }
1106 
1111  public static bool BeginPopupContextVoid()
1112  {
1113  byte* nativeStrId = null;
1114  ImGuiPopupFlags popupFlags = (ImGuiPopupFlags) 1;
1115  byte ret = ImGuiNative.igBeginPopupContextVoid(nativeStrId, popupFlags);
1116  return ret != 0;
1117  }
1118 
1124  public static bool BeginPopupContextVoid(string strId)
1125  {
1126  byte* nativeStrId;
1127  int strIdByteCount = 0;
1128  if (strId != null)
1129  {
1130  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1131  if (strIdByteCount > Util.StackAllocationSizeLimit)
1132  {
1133  nativeStrId = Util.Allocate(strIdByteCount + 1);
1134  }
1135  else
1136  {
1137  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1138  nativeStrId = nativeStrIdStackBytes;
1139  }
1140 
1141  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1142  nativeStrId[nativeStrIdOffset] = 0;
1143  }
1144  else
1145  {
1146  nativeStrId = null;
1147  }
1148 
1149  ImGuiPopupFlags popupFlags = (ImGuiPopupFlags) 1;
1150  byte ret = ImGuiNative.igBeginPopupContextVoid(nativeStrId, popupFlags);
1151  if (strIdByteCount > Util.StackAllocationSizeLimit)
1152  {
1153  Util.Free(nativeStrId);
1154  }
1155 
1156  return ret != 0;
1157  }
1158 
1165  public static bool BeginPopupContextVoid(string strId, ImGuiPopupFlags popupFlags)
1166  {
1167  byte* nativeStrId;
1168  int strIdByteCount = 0;
1169  if (strId != null)
1170  {
1171  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1172  if (strIdByteCount > Util.StackAllocationSizeLimit)
1173  {
1174  nativeStrId = Util.Allocate(strIdByteCount + 1);
1175  }
1176  else
1177  {
1178  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1179  nativeStrId = nativeStrIdStackBytes;
1180  }
1181 
1182  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1183  nativeStrId[nativeStrIdOffset] = 0;
1184  }
1185  else
1186  {
1187  nativeStrId = null;
1188  }
1189 
1190  byte ret = ImGuiNative.igBeginPopupContextVoid(nativeStrId, popupFlags);
1191  if (strIdByteCount > Util.StackAllocationSizeLimit)
1192  {
1193  Util.Free(nativeStrId);
1194  }
1195 
1196  return ret != 0;
1197  }
1198 
1203  public static bool BeginPopupContextWindow()
1204  {
1205  byte* nativeStrId = null;
1206  ImGuiPopupFlags popupFlags = (ImGuiPopupFlags) 1;
1207  byte ret = ImGuiNative.igBeginPopupContextWindow(nativeStrId, popupFlags);
1208  return ret != 0;
1209  }
1210 
1216  public static bool BeginPopupContextWindow(string strId)
1217  {
1218  byte* nativeStrId;
1219  int strIdByteCount = 0;
1220  if (strId != null)
1221  {
1222  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1223  if (strIdByteCount > Util.StackAllocationSizeLimit)
1224  {
1225  nativeStrId = Util.Allocate(strIdByteCount + 1);
1226  }
1227  else
1228  {
1229  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1230  nativeStrId = nativeStrIdStackBytes;
1231  }
1232 
1233  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1234  nativeStrId[nativeStrIdOffset] = 0;
1235  }
1236  else
1237  {
1238  nativeStrId = null;
1239  }
1240 
1241  ImGuiPopupFlags popupFlags = (ImGuiPopupFlags) 1;
1242  byte ret = ImGuiNative.igBeginPopupContextWindow(nativeStrId, popupFlags);
1243  if (strIdByteCount > Util.StackAllocationSizeLimit)
1244  {
1245  Util.Free(nativeStrId);
1246  }
1247 
1248  return ret != 0;
1249  }
1250 
1257  public static bool BeginPopupContextWindow(string strId, ImGuiPopupFlags popupFlags)
1258  {
1259  byte* nativeStrId;
1260  int strIdByteCount = 0;
1261  if (strId != null)
1262  {
1263  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1264  if (strIdByteCount > Util.StackAllocationSizeLimit)
1265  {
1266  nativeStrId = Util.Allocate(strIdByteCount + 1);
1267  }
1268  else
1269  {
1270  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1271  nativeStrId = nativeStrIdStackBytes;
1272  }
1273 
1274  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1275  nativeStrId[nativeStrIdOffset] = 0;
1276  }
1277  else
1278  {
1279  nativeStrId = null;
1280  }
1281 
1282  byte ret = ImGuiNative.igBeginPopupContextWindow(nativeStrId, popupFlags);
1283  if (strIdByteCount > Util.StackAllocationSizeLimit)
1284  {
1285  Util.Free(nativeStrId);
1286  }
1287 
1288  return ret != 0;
1289  }
1290 
1296  public static bool BeginPopupModal(string name)
1297  {
1298  byte* nativeName;
1299  int nameByteCount = 0;
1300  if (name != null)
1301  {
1302  nameByteCount = Encoding.UTF8.GetByteCount(name);
1303  if (nameByteCount > Util.StackAllocationSizeLimit)
1304  {
1305  nativeName = Util.Allocate(nameByteCount + 1);
1306  }
1307  else
1308  {
1309  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
1310  nativeName = nativeNameStackBytes;
1311  }
1312 
1313  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
1314  nativeName[nativeNameOffset] = 0;
1315  }
1316  else
1317  {
1318  nativeName = null;
1319  }
1320 
1321  byte* pOpen = null;
1322  ImGuiWindowFlags flags = 0;
1323  byte ret = ImGuiNative.igBeginPopupModal(nativeName, pOpen, flags);
1324  if (nameByteCount > Util.StackAllocationSizeLimit)
1325  {
1326  Util.Free(nativeName);
1327  }
1328 
1329  return ret != 0;
1330  }
1331 
1338  public static bool BeginPopupModal(string name, ref bool pOpen)
1339  {
1340  byte* nativeName;
1341  int nameByteCount = 0;
1342  if (name != null)
1343  {
1344  nameByteCount = Encoding.UTF8.GetByteCount(name);
1345  if (nameByteCount > Util.StackAllocationSizeLimit)
1346  {
1347  nativeName = Util.Allocate(nameByteCount + 1);
1348  }
1349  else
1350  {
1351  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
1352  nativeName = nativeNameStackBytes;
1353  }
1354 
1355  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
1356  nativeName[nativeNameOffset] = 0;
1357  }
1358  else
1359  {
1360  nativeName = null;
1361  }
1362 
1363  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
1364  byte* nativePOpen = &nativePOpenVal;
1365  ImGuiWindowFlags flags = 0;
1366  byte ret = ImGuiNative.igBeginPopupModal(nativeName, nativePOpen, flags);
1367  if (nameByteCount > Util.StackAllocationSizeLimit)
1368  {
1369  Util.Free(nativeName);
1370  }
1371 
1372  pOpen = nativePOpenVal != 0;
1373  return ret != 0;
1374  }
1375 
1383  public static bool BeginPopupModal(string name, ref bool pOpen, ImGuiWindowFlags flags)
1384  {
1385  byte* nativeName;
1386  int nameByteCount = 0;
1387  if (name != null)
1388  {
1389  nameByteCount = Encoding.UTF8.GetByteCount(name);
1390  if (nameByteCount > Util.StackAllocationSizeLimit)
1391  {
1392  nativeName = Util.Allocate(nameByteCount + 1);
1393  }
1394  else
1395  {
1396  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
1397  nativeName = nativeNameStackBytes;
1398  }
1399 
1400  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
1401  nativeName[nativeNameOffset] = 0;
1402  }
1403  else
1404  {
1405  nativeName = null;
1406  }
1407 
1408  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
1409  byte* nativePOpen = &nativePOpenVal;
1410  byte ret = ImGuiNative.igBeginPopupModal(nativeName, nativePOpen, flags);
1411  if (nameByteCount > Util.StackAllocationSizeLimit)
1412  {
1413  Util.Free(nativeName);
1414  }
1415 
1416  pOpen = nativePOpenVal != 0;
1417  return ret != 0;
1418  }
1419 
1425  public static bool BeginTabBar(string strId)
1426  {
1427  byte* nativeStrId;
1428  int strIdByteCount = 0;
1429  if (strId != null)
1430  {
1431  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1432  if (strIdByteCount > Util.StackAllocationSizeLimit)
1433  {
1434  nativeStrId = Util.Allocate(strIdByteCount + 1);
1435  }
1436  else
1437  {
1438  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1439  nativeStrId = nativeStrIdStackBytes;
1440  }
1441 
1442  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1443  nativeStrId[nativeStrIdOffset] = 0;
1444  }
1445  else
1446  {
1447  nativeStrId = null;
1448  }
1449 
1450  ImGuiTabBarFlags flags = 0;
1451  byte ret = ImGuiNative.igBeginTabBar(nativeStrId, flags);
1452  if (strIdByteCount > Util.StackAllocationSizeLimit)
1453  {
1454  Util.Free(nativeStrId);
1455  }
1456 
1457  return ret != 0;
1458  }
1459 
1466  public static bool BeginTabBar(string strId, ImGuiTabBarFlags flags)
1467  {
1468  byte* nativeStrId;
1469  int strIdByteCount = 0;
1470  if (strId != null)
1471  {
1472  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1473  if (strIdByteCount > Util.StackAllocationSizeLimit)
1474  {
1475  nativeStrId = Util.Allocate(strIdByteCount + 1);
1476  }
1477  else
1478  {
1479  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1480  nativeStrId = nativeStrIdStackBytes;
1481  }
1482 
1483  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1484  nativeStrId[nativeStrIdOffset] = 0;
1485  }
1486  else
1487  {
1488  nativeStrId = null;
1489  }
1490 
1491  byte ret = ImGuiNative.igBeginTabBar(nativeStrId, flags);
1492  if (strIdByteCount > Util.StackAllocationSizeLimit)
1493  {
1494  Util.Free(nativeStrId);
1495  }
1496 
1497  return ret != 0;
1498  }
1499 
1505  public static bool BeginTabItem(string label)
1506  {
1507  byte* nativeLabel;
1508  int labelByteCount = 0;
1509  if (label != null)
1510  {
1511  labelByteCount = Encoding.UTF8.GetByteCount(label);
1512  if (labelByteCount > Util.StackAllocationSizeLimit)
1513  {
1514  nativeLabel = Util.Allocate(labelByteCount + 1);
1515  }
1516  else
1517  {
1518  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1519  nativeLabel = nativeLabelStackBytes;
1520  }
1521 
1522  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1523  nativeLabel[nativeLabelOffset] = 0;
1524  }
1525  else
1526  {
1527  nativeLabel = null;
1528  }
1529 
1530  byte* pOpen = null;
1531  ImGuiTabItemFlags flags = 0;
1532  byte ret = ImGuiNative.igBeginTabItem(nativeLabel, pOpen, flags);
1533  if (labelByteCount > Util.StackAllocationSizeLimit)
1534  {
1535  Util.Free(nativeLabel);
1536  }
1537 
1538  return ret != 0;
1539  }
1540 
1547  public static bool BeginTabItem(string label, ref bool pOpen)
1548  {
1549  byte* nativeLabel;
1550  int labelByteCount = 0;
1551  if (label != null)
1552  {
1553  labelByteCount = Encoding.UTF8.GetByteCount(label);
1554  if (labelByteCount > Util.StackAllocationSizeLimit)
1555  {
1556  nativeLabel = Util.Allocate(labelByteCount + 1);
1557  }
1558  else
1559  {
1560  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1561  nativeLabel = nativeLabelStackBytes;
1562  }
1563 
1564  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1565  nativeLabel[nativeLabelOffset] = 0;
1566  }
1567  else
1568  {
1569  nativeLabel = null;
1570  }
1571 
1572  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
1573  byte* nativePOpen = &nativePOpenVal;
1574  ImGuiTabItemFlags flags = 0;
1575  byte ret = ImGuiNative.igBeginTabItem(nativeLabel, nativePOpen, flags);
1576  if (labelByteCount > Util.StackAllocationSizeLimit)
1577  {
1578  Util.Free(nativeLabel);
1579  }
1580 
1581  pOpen = nativePOpenVal != 0;
1582  return ret != 0;
1583  }
1584 
1592  public static bool BeginTabItem(string label, ref bool pOpen, ImGuiTabItemFlags flags)
1593  {
1594  byte* nativeLabel;
1595  int labelByteCount = 0;
1596  if (label != null)
1597  {
1598  labelByteCount = Encoding.UTF8.GetByteCount(label);
1599  if (labelByteCount > Util.StackAllocationSizeLimit)
1600  {
1601  nativeLabel = Util.Allocate(labelByteCount + 1);
1602  }
1603  else
1604  {
1605  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1606  nativeLabel = nativeLabelStackBytes;
1607  }
1608 
1609  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1610  nativeLabel[nativeLabelOffset] = 0;
1611  }
1612  else
1613  {
1614  nativeLabel = null;
1615  }
1616 
1617  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
1618  byte* nativePOpen = &nativePOpenVal;
1619  byte ret = ImGuiNative.igBeginTabItem(nativeLabel, nativePOpen, flags);
1620  if (labelByteCount > Util.StackAllocationSizeLimit)
1621  {
1622  Util.Free(nativeLabel);
1623  }
1624 
1625  pOpen = nativePOpenVal != 0;
1626  return ret != 0;
1627  }
1628 
1635  public static bool BeginTable(string strId, int column)
1636  {
1637  byte* nativeStrId;
1638  int strIdByteCount = 0;
1639  if (strId != null)
1640  {
1641  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1642  if (strIdByteCount > Util.StackAllocationSizeLimit)
1643  {
1644  nativeStrId = Util.Allocate(strIdByteCount + 1);
1645  }
1646  else
1647  {
1648  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1649  nativeStrId = nativeStrIdStackBytes;
1650  }
1651 
1652  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1653  nativeStrId[nativeStrIdOffset] = 0;
1654  }
1655  else
1656  {
1657  nativeStrId = null;
1658  }
1659 
1660  ImGuiTableFlags flags = 0;
1661  Vector2F outerSize = new Vector2F();
1662  float innerWidth = 0.0f;
1663  byte ret = ImGuiNative.igBeginTable(nativeStrId, column, flags, outerSize, innerWidth);
1664  if (strIdByteCount > Util.StackAllocationSizeLimit)
1665  {
1666  Util.Free(nativeStrId);
1667  }
1668 
1669  return ret != 0;
1670  }
1671 
1679  public static bool BeginTable(string strId, int column, ImGuiTableFlags flags)
1680  {
1681  byte* nativeStrId;
1682  int strIdByteCount = 0;
1683  if (strId != null)
1684  {
1685  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1686  if (strIdByteCount > Util.StackAllocationSizeLimit)
1687  {
1688  nativeStrId = Util.Allocate(strIdByteCount + 1);
1689  }
1690  else
1691  {
1692  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1693  nativeStrId = nativeStrIdStackBytes;
1694  }
1695 
1696  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1697  nativeStrId[nativeStrIdOffset] = 0;
1698  }
1699  else
1700  {
1701  nativeStrId = null;
1702  }
1703 
1704  Vector2F outerSize = new Vector2F();
1705  float innerWidth = 0.0f;
1706  byte ret = ImGuiNative.igBeginTable(nativeStrId, column, flags, outerSize, innerWidth);
1707  if (strIdByteCount > Util.StackAllocationSizeLimit)
1708  {
1709  Util.Free(nativeStrId);
1710  }
1711 
1712  return ret != 0;
1713  }
1714 
1723  public static bool BeginTable(string strId, int column, ImGuiTableFlags flags, Vector2F outerSize)
1724  {
1725  byte* nativeStrId;
1726  int strIdByteCount = 0;
1727  if (strId != null)
1728  {
1729  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1730  if (strIdByteCount > Util.StackAllocationSizeLimit)
1731  {
1732  nativeStrId = Util.Allocate(strIdByteCount + 1);
1733  }
1734  else
1735  {
1736  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1737  nativeStrId = nativeStrIdStackBytes;
1738  }
1739 
1740  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1741  nativeStrId[nativeStrIdOffset] = 0;
1742  }
1743  else
1744  {
1745  nativeStrId = null;
1746  }
1747 
1748  float innerWidth = 0.0f;
1749  byte ret = ImGuiNative.igBeginTable(nativeStrId, column, flags, outerSize, innerWidth);
1750  if (strIdByteCount > Util.StackAllocationSizeLimit)
1751  {
1752  Util.Free(nativeStrId);
1753  }
1754 
1755  return ret != 0;
1756  }
1757 
1767  public static bool BeginTable(string strId, int column, ImGuiTableFlags flags, Vector2F outerSize, float innerWidth)
1768  {
1769  byte* nativeStrId;
1770  int strIdByteCount = 0;
1771  if (strId != null)
1772  {
1773  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1774  if (strIdByteCount > Util.StackAllocationSizeLimit)
1775  {
1776  nativeStrId = Util.Allocate(strIdByteCount + 1);
1777  }
1778  else
1779  {
1780  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1781  nativeStrId = nativeStrIdStackBytes;
1782  }
1783 
1784  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1785  nativeStrId[nativeStrIdOffset] = 0;
1786  }
1787  else
1788  {
1789  nativeStrId = null;
1790  }
1791 
1792  byte ret = ImGuiNative.igBeginTable(nativeStrId, column, flags, outerSize, innerWidth);
1793  if (strIdByteCount > Util.StackAllocationSizeLimit)
1794  {
1795  Util.Free(nativeStrId);
1796  }
1797 
1798  return ret != 0;
1799  }
1800 
1805  public static bool BeginTooltip()
1806  {
1807  byte ret = ImGuiNative.igBeginTooltip();
1808  return ret != 0;
1809  }
1810 
1814  public static void Bullet()
1815  {
1816  ImGuiNative.igBullet();
1817  }
1818 
1823  public static void BulletText(string fmt)
1824  {
1825  byte* nativeFmt;
1826  int fmtByteCount = 0;
1827  if (fmt != null)
1828  {
1829  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
1830  if (fmtByteCount > Util.StackAllocationSizeLimit)
1831  {
1832  nativeFmt = Util.Allocate(fmtByteCount + 1);
1833  }
1834  else
1835  {
1836  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
1837  nativeFmt = nativeFmtStackBytes;
1838  }
1839 
1840  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
1841  nativeFmt[nativeFmtOffset] = 0;
1842  }
1843  else
1844  {
1845  nativeFmt = null;
1846  }
1847 
1848  ImGuiNative.igBulletText(nativeFmt);
1849  if (fmtByteCount > Util.StackAllocationSizeLimit)
1850  {
1851  Util.Free(nativeFmt);
1852  }
1853  }
1854 
1860  public static bool Button(string label)
1861  {
1862  byte* nativeLabel;
1863  int labelByteCount = 0;
1864  if (label != null)
1865  {
1866  labelByteCount = Encoding.UTF8.GetByteCount(label);
1867  if (labelByteCount > Util.StackAllocationSizeLimit)
1868  {
1869  nativeLabel = Util.Allocate(labelByteCount + 1);
1870  }
1871  else
1872  {
1873  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1874  nativeLabel = nativeLabelStackBytes;
1875  }
1876 
1877  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1878  nativeLabel[nativeLabelOffset] = 0;
1879  }
1880  else
1881  {
1882  nativeLabel = null;
1883  }
1884 
1885  Vector2F size = new Vector2F();
1886  byte ret = ImGuiNative.igButton(nativeLabel, size);
1887  if (labelByteCount > Util.StackAllocationSizeLimit)
1888  {
1889  Util.Free(nativeLabel);
1890  }
1891 
1892  return ret != 0;
1893  }
1894 
1901  public static bool Button(string label, Vector2F size)
1902  {
1903  byte* nativeLabel;
1904  int labelByteCount = 0;
1905  if (label != null)
1906  {
1907  labelByteCount = Encoding.UTF8.GetByteCount(label);
1908  if (labelByteCount > Util.StackAllocationSizeLimit)
1909  {
1910  nativeLabel = Util.Allocate(labelByteCount + 1);
1911  }
1912  else
1913  {
1914  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1915  nativeLabel = nativeLabelStackBytes;
1916  }
1917 
1918  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1919  nativeLabel[nativeLabelOffset] = 0;
1920  }
1921  else
1922  {
1923  nativeLabel = null;
1924  }
1925 
1926  byte ret = ImGuiNative.igButton(nativeLabel, size);
1927  if (labelByteCount > Util.StackAllocationSizeLimit)
1928  {
1929  Util.Free(nativeLabel);
1930  }
1931 
1932  return ret != 0;
1933  }
1934 
1939  public static float CalcItemWidth()
1940  {
1941  float ret = ImGuiNative.igCalcItemWidth();
1942  return ret;
1943  }
1944 
1951  public static bool Checkbox(string label, ref bool v)
1952  {
1953  byte* nativeLabel;
1954  int labelByteCount = 0;
1955  if (label != null)
1956  {
1957  labelByteCount = Encoding.UTF8.GetByteCount(label);
1958  if (labelByteCount > Util.StackAllocationSizeLimit)
1959  {
1960  nativeLabel = Util.Allocate(labelByteCount + 1);
1961  }
1962  else
1963  {
1964  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1965  nativeLabel = nativeLabelStackBytes;
1966  }
1967 
1968  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1969  nativeLabel[nativeLabelOffset] = 0;
1970  }
1971  else
1972  {
1973  nativeLabel = null;
1974  }
1975 
1976  byte nativeVVal = v ? (byte) 1 : (byte) 0;
1977  byte* nativeV = &nativeVVal;
1978  byte ret = ImGuiNative.igCheckbox(nativeLabel, nativeV);
1979  if (labelByteCount > Util.StackAllocationSizeLimit)
1980  {
1981  Util.Free(nativeLabel);
1982  }
1983 
1984  v = nativeVVal != 0;
1985  return ret != 0;
1986  }
1987 
1995  public static bool CheckboxFlags(string label, ref int flags, int flagsValue)
1996  {
1997  byte* nativeLabel;
1998  int labelByteCount = 0;
1999  if (label != null)
2000  {
2001  labelByteCount = Encoding.UTF8.GetByteCount(label);
2002  if (labelByteCount > Util.StackAllocationSizeLimit)
2003  {
2004  nativeLabel = Util.Allocate(labelByteCount + 1);
2005  }
2006  else
2007  {
2008  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2009  nativeLabel = nativeLabelStackBytes;
2010  }
2011 
2012  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2013  nativeLabel[nativeLabelOffset] = 0;
2014  }
2015  else
2016  {
2017  nativeLabel = null;
2018  }
2019 
2020  fixed (int* nativeFlags = &flags)
2021  {
2022  byte ret = ImGuiNative.igCheckboxFlags_IntPtr(nativeLabel, nativeFlags, flagsValue);
2023  if (labelByteCount > Util.StackAllocationSizeLimit)
2024  {
2025  Util.Free(nativeLabel);
2026  }
2027 
2028  return ret != 0;
2029  }
2030  }
2031 
2039  public static bool CheckboxFlags(string label, ref uint flags, uint flagsValue)
2040  {
2041  byte* nativeLabel;
2042  int labelByteCount = 0;
2043  if (label != null)
2044  {
2045  labelByteCount = Encoding.UTF8.GetByteCount(label);
2046  if (labelByteCount > Util.StackAllocationSizeLimit)
2047  {
2048  nativeLabel = Util.Allocate(labelByteCount + 1);
2049  }
2050  else
2051  {
2052  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2053  nativeLabel = nativeLabelStackBytes;
2054  }
2055 
2056  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2057  nativeLabel[nativeLabelOffset] = 0;
2058  }
2059  else
2060  {
2061  nativeLabel = null;
2062  }
2063 
2064  fixed (uint* nativeFlags = &flags)
2065  {
2066  byte ret = ImGuiNative.igCheckboxFlags_UintPtr(nativeLabel, nativeFlags, flagsValue);
2067  if (labelByteCount > Util.StackAllocationSizeLimit)
2068  {
2069  Util.Free(nativeLabel);
2070  }
2071 
2072  return ret != 0;
2073  }
2074  }
2075 
2079  public static void CloseCurrentPopup()
2080  {
2081  ImGuiNative.igCloseCurrentPopup();
2082  }
2083 
2089  public static bool CollapsingHeader(string label)
2090  {
2091  byte* nativeLabel;
2092  int labelByteCount = 0;
2093  if (label != null)
2094  {
2095  labelByteCount = Encoding.UTF8.GetByteCount(label);
2096  if (labelByteCount > Util.StackAllocationSizeLimit)
2097  {
2098  nativeLabel = Util.Allocate(labelByteCount + 1);
2099  }
2100  else
2101  {
2102  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2103  nativeLabel = nativeLabelStackBytes;
2104  }
2105 
2106  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2107  nativeLabel[nativeLabelOffset] = 0;
2108  }
2109  else
2110  {
2111  nativeLabel = null;
2112  }
2113 
2114  ImGuiTreeNodeFlags flags = 0;
2115  byte ret = ImGuiNative.igCollapsingHeader_TreeNodeFlags(nativeLabel, flags);
2116  if (labelByteCount > Util.StackAllocationSizeLimit)
2117  {
2118  Util.Free(nativeLabel);
2119  }
2120 
2121  return ret != 0;
2122  }
2123 
2130  public static bool CollapsingHeader(string label, ImGuiTreeNodeFlags flags)
2131  {
2132  byte* nativeLabel;
2133  int labelByteCount = 0;
2134  if (label != null)
2135  {
2136  labelByteCount = Encoding.UTF8.GetByteCount(label);
2137  if (labelByteCount > Util.StackAllocationSizeLimit)
2138  {
2139  nativeLabel = Util.Allocate(labelByteCount + 1);
2140  }
2141  else
2142  {
2143  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2144  nativeLabel = nativeLabelStackBytes;
2145  }
2146 
2147  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2148  nativeLabel[nativeLabelOffset] = 0;
2149  }
2150  else
2151  {
2152  nativeLabel = null;
2153  }
2154 
2155  byte ret = ImGuiNative.igCollapsingHeader_TreeNodeFlags(nativeLabel, flags);
2156  if (labelByteCount > Util.StackAllocationSizeLimit)
2157  {
2158  Util.Free(nativeLabel);
2159  }
2160 
2161  return ret != 0;
2162  }
2163 
2170  public static bool CollapsingHeader(string label, ref bool pVisible)
2171  {
2172  byte* nativeLabel;
2173  int labelByteCount = 0;
2174  if (label != null)
2175  {
2176  labelByteCount = Encoding.UTF8.GetByteCount(label);
2177  if (labelByteCount > Util.StackAllocationSizeLimit)
2178  {
2179  nativeLabel = Util.Allocate(labelByteCount + 1);
2180  }
2181  else
2182  {
2183  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2184  nativeLabel = nativeLabelStackBytes;
2185  }
2186 
2187  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2188  nativeLabel[nativeLabelOffset] = 0;
2189  }
2190  else
2191  {
2192  nativeLabel = null;
2193  }
2194 
2195  byte nativePVisibleVal = pVisible ? (byte) 1 : (byte) 0;
2196  byte* nativePVisible = &nativePVisibleVal;
2197  ImGuiTreeNodeFlags flags = 0;
2198  byte ret = ImGuiNative.igCollapsingHeader_BoolPtr(nativeLabel, nativePVisible, flags);
2199  if (labelByteCount > Util.StackAllocationSizeLimit)
2200  {
2201  Util.Free(nativeLabel);
2202  }
2203 
2204  pVisible = nativePVisibleVal != 0;
2205  return ret != 0;
2206  }
2207 
2215  public static bool CollapsingHeader(string label, ref bool pVisible, ImGuiTreeNodeFlags flags)
2216  {
2217  byte* nativeLabel;
2218  int labelByteCount = 0;
2219  if (label != null)
2220  {
2221  labelByteCount = Encoding.UTF8.GetByteCount(label);
2222  if (labelByteCount > Util.StackAllocationSizeLimit)
2223  {
2224  nativeLabel = Util.Allocate(labelByteCount + 1);
2225  }
2226  else
2227  {
2228  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2229  nativeLabel = nativeLabelStackBytes;
2230  }
2231 
2232  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2233  nativeLabel[nativeLabelOffset] = 0;
2234  }
2235  else
2236  {
2237  nativeLabel = null;
2238  }
2239 
2240  byte nativePVisibleVal = pVisible ? (byte) 1 : (byte) 0;
2241  byte* nativePVisible = &nativePVisibleVal;
2242  byte ret = ImGuiNative.igCollapsingHeader_BoolPtr(nativeLabel, nativePVisible, flags);
2243  if (labelByteCount > Util.StackAllocationSizeLimit)
2244  {
2245  Util.Free(nativeLabel);
2246  }
2247 
2248  pVisible = nativePVisibleVal != 0;
2249  return ret != 0;
2250  }
2251 
2258  public static bool ColorButton(string descId, Vector4F col)
2259  {
2260  byte* nativeDescId;
2261  int descIdByteCount = 0;
2262  if (descId != null)
2263  {
2264  descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2265  if (descIdByteCount > Util.StackAllocationSizeLimit)
2266  {
2267  nativeDescId = Util.Allocate(descIdByteCount + 1);
2268  }
2269  else
2270  {
2271  byte* nativeDescIdStackBytes = stackalloc byte[descIdByteCount + 1];
2272  nativeDescId = nativeDescIdStackBytes;
2273  }
2274 
2275  int nativeDescIdOffset = Util.GetUtf8(descId, nativeDescId, descIdByteCount);
2276  nativeDescId[nativeDescIdOffset] = 0;
2277  }
2278  else
2279  {
2280  nativeDescId = null;
2281  }
2282 
2283  ImGuiColorEditFlags flags = 0;
2284  Vector2F size = new Vector2F();
2285  byte ret = ImGuiNative.igColorButton(nativeDescId, col, flags, size);
2286  if (descIdByteCount > Util.StackAllocationSizeLimit)
2287  {
2288  Util.Free(nativeDescId);
2289  }
2290 
2291  return ret != 0;
2292  }
2293 
2301  public static bool ColorButton(string descId, Vector4F col, ImGuiColorEditFlags flags)
2302  {
2303  byte* nativeDescId;
2304  int descIdByteCount = 0;
2305  if (descId != null)
2306  {
2307  descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2308  if (descIdByteCount > Util.StackAllocationSizeLimit)
2309  {
2310  nativeDescId = Util.Allocate(descIdByteCount + 1);
2311  }
2312  else
2313  {
2314  byte* nativeDescIdStackBytes = stackalloc byte[descIdByteCount + 1];
2315  nativeDescId = nativeDescIdStackBytes;
2316  }
2317 
2318  int nativeDescIdOffset = Util.GetUtf8(descId, nativeDescId, descIdByteCount);
2319  nativeDescId[nativeDescIdOffset] = 0;
2320  }
2321  else
2322  {
2323  nativeDescId = null;
2324  }
2325 
2326  Vector2F size = new Vector2F();
2327  byte ret = ImGuiNative.igColorButton(nativeDescId, col, flags, size);
2328  if (descIdByteCount > Util.StackAllocationSizeLimit)
2329  {
2330  Util.Free(nativeDescId);
2331  }
2332 
2333  return ret != 0;
2334  }
2335 
2344  public static bool ColorButton(string descId, Vector4F col, ImGuiColorEditFlags flags, Vector2F size)
2345  {
2346  byte* nativeDescId;
2347  int descIdByteCount = 0;
2348  if (descId != null)
2349  {
2350  descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2351  if (descIdByteCount > Util.StackAllocationSizeLimit)
2352  {
2353  nativeDescId = Util.Allocate(descIdByteCount + 1);
2354  }
2355  else
2356  {
2357  byte* nativeDescIdStackBytes = stackalloc byte[descIdByteCount + 1];
2358  nativeDescId = nativeDescIdStackBytes;
2359  }
2360 
2361  int nativeDescIdOffset = Util.GetUtf8(descId, nativeDescId, descIdByteCount);
2362  nativeDescId[nativeDescIdOffset] = 0;
2363  }
2364  else
2365  {
2366  nativeDescId = null;
2367  }
2368 
2369  byte ret = ImGuiNative.igColorButton(nativeDescId, col, flags, size);
2370  if (descIdByteCount > Util.StackAllocationSizeLimit)
2371  {
2372  Util.Free(nativeDescId);
2373  }
2374 
2375  return ret != 0;
2376  }
2377 
2382  public static uint ColorConvertFloat4ToU32(Vector4F @in)
2383  {
2384  uint ret = ImGuiNative.igColorConvertFloat4ToU32(@in);
2385  return ret;
2386  }
2387 
2397  public static void ColorConvertHsVtoRgb(float h, float s, float v, out float outR, out float outG, out float outB)
2398  {
2399  fixed (float* nativeOutR = &outR)
2400  {
2401  fixed (float* nativeOutG = &outG)
2402  {
2403  fixed (float* nativeOutB = &outB)
2404  {
2405  ImGuiNative.igColorConvertHSVtoRGB(h, s, v, nativeOutR, nativeOutG, nativeOutB);
2406  }
2407  }
2408  }
2409  }
2410 
2420  public static void ColorConvertRgBtoHsv(float r, float g, float b, out float outH, out float outS, out float outV)
2421  {
2422  fixed (float* nativeOutH = &outH)
2423  {
2424  fixed (float* nativeOutS = &outS)
2425  {
2426  fixed (float* nativeOutV = &outV)
2427  {
2428  ImGuiNative.igColorConvertRGBtoHSV(r, g, b, nativeOutH, nativeOutS, nativeOutV);
2429  }
2430  }
2431  }
2432  }
2433 
2439  public static Vector4F ColorConvertU32ToFloat4(uint @in)
2440  {
2441  Vector4F retval;
2442  ImGuiNative.igColorConvertU32ToFloat4(&retval, @in);
2443  return retval;
2444  }
2445 
2452  public static bool ColorEdit3(string label, ref Vector3F col)
2453  {
2454  byte* nativeLabel;
2455  int labelByteCount = 0;
2456  if (label != null)
2457  {
2458  labelByteCount = Encoding.UTF8.GetByteCount(label);
2459  if (labelByteCount > Util.StackAllocationSizeLimit)
2460  {
2461  nativeLabel = Util.Allocate(labelByteCount + 1);
2462  }
2463  else
2464  {
2465  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2466  nativeLabel = nativeLabelStackBytes;
2467  }
2468 
2469  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2470  nativeLabel[nativeLabelOffset] = 0;
2471  }
2472  else
2473  {
2474  nativeLabel = null;
2475  }
2476 
2477  ImGuiColorEditFlags flags = 0;
2478  fixed (Vector3F* nativeCol = &col)
2479  {
2480  byte ret = ImGuiNative.igColorEdit3(nativeLabel, nativeCol, flags);
2481  if (labelByteCount > Util.StackAllocationSizeLimit)
2482  {
2483  Util.Free(nativeLabel);
2484  }
2485 
2486  return ret != 0;
2487  }
2488  }
2489 
2497  public static bool ColorEdit3(string label, ref Vector3F col, ImGuiColorEditFlags flags)
2498  {
2499  byte* nativeLabel;
2500  int labelByteCount = 0;
2501  if (label != null)
2502  {
2503  labelByteCount = Encoding.UTF8.GetByteCount(label);
2504  if (labelByteCount > Util.StackAllocationSizeLimit)
2505  {
2506  nativeLabel = Util.Allocate(labelByteCount + 1);
2507  }
2508  else
2509  {
2510  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2511  nativeLabel = nativeLabelStackBytes;
2512  }
2513 
2514  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2515  nativeLabel[nativeLabelOffset] = 0;
2516  }
2517  else
2518  {
2519  nativeLabel = null;
2520  }
2521 
2522  fixed (Vector3F* nativeCol = &col)
2523  {
2524  byte ret = ImGuiNative.igColorEdit3(nativeLabel, nativeCol, flags);
2525  if (labelByteCount > Util.StackAllocationSizeLimit)
2526  {
2527  Util.Free(nativeLabel);
2528  }
2529 
2530  return ret != 0;
2531  }
2532  }
2533 
2540  public static bool ColorEdit4(string label, ref Vector4F col)
2541  {
2542  byte* nativeLabel;
2543  int labelByteCount = 0;
2544  if (label != null)
2545  {
2546  labelByteCount = Encoding.UTF8.GetByteCount(label);
2547  if (labelByteCount > Util.StackAllocationSizeLimit)
2548  {
2549  nativeLabel = Util.Allocate(labelByteCount + 1);
2550  }
2551  else
2552  {
2553  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2554  nativeLabel = nativeLabelStackBytes;
2555  }
2556 
2557  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2558  nativeLabel[nativeLabelOffset] = 0;
2559  }
2560  else
2561  {
2562  nativeLabel = null;
2563  }
2564 
2565  ImGuiColorEditFlags flags = 0;
2566  fixed (Vector4F* nativeCol = &col)
2567  {
2568  byte ret = ImGuiNative.igColorEdit4(nativeLabel, nativeCol, flags);
2569  if (labelByteCount > Util.StackAllocationSizeLimit)
2570  {
2571  Util.Free(nativeLabel);
2572  }
2573 
2574  return ret != 0;
2575  }
2576  }
2577 
2585  public static bool ColorEdit4(string label, ref Vector4F col, ImGuiColorEditFlags flags)
2586  {
2587  byte* nativeLabel;
2588  int labelByteCount = 0;
2589  if (label != null)
2590  {
2591  labelByteCount = Encoding.UTF8.GetByteCount(label);
2592  if (labelByteCount > Util.StackAllocationSizeLimit)
2593  {
2594  nativeLabel = Util.Allocate(labelByteCount + 1);
2595  }
2596  else
2597  {
2598  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2599  nativeLabel = nativeLabelStackBytes;
2600  }
2601 
2602  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2603  nativeLabel[nativeLabelOffset] = 0;
2604  }
2605  else
2606  {
2607  nativeLabel = null;
2608  }
2609 
2610  fixed (Vector4F* nativeCol = &col)
2611  {
2612  byte ret = ImGuiNative.igColorEdit4(nativeLabel, nativeCol, flags);
2613  if (labelByteCount > Util.StackAllocationSizeLimit)
2614  {
2615  Util.Free(nativeLabel);
2616  }
2617 
2618  return ret != 0;
2619  }
2620  }
2621 
2628  public static bool ColorPicker3(string label, ref Vector3F col)
2629  {
2630  byte* nativeLabel;
2631  int labelByteCount = 0;
2632  if (label != null)
2633  {
2634  labelByteCount = Encoding.UTF8.GetByteCount(label);
2635  if (labelByteCount > Util.StackAllocationSizeLimit)
2636  {
2637  nativeLabel = Util.Allocate(labelByteCount + 1);
2638  }
2639  else
2640  {
2641  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2642  nativeLabel = nativeLabelStackBytes;
2643  }
2644 
2645  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2646  nativeLabel[nativeLabelOffset] = 0;
2647  }
2648  else
2649  {
2650  nativeLabel = null;
2651  }
2652 
2653  ImGuiColorEditFlags flags = 0;
2654  fixed (Vector3F* nativeCol = &col)
2655  {
2656  byte ret = ImGuiNative.igColorPicker3(nativeLabel, nativeCol, flags);
2657  if (labelByteCount > Util.StackAllocationSizeLimit)
2658  {
2659  Util.Free(nativeLabel);
2660  }
2661 
2662  return ret != 0;
2663  }
2664  }
2665 
2673  public static bool ColorPicker3(string label, ref Vector3F col, ImGuiColorEditFlags flags)
2674  {
2675  byte* nativeLabel;
2676  int labelByteCount = 0;
2677  if (label != null)
2678  {
2679  labelByteCount = Encoding.UTF8.GetByteCount(label);
2680  if (labelByteCount > Util.StackAllocationSizeLimit)
2681  {
2682  nativeLabel = Util.Allocate(labelByteCount + 1);
2683  }
2684  else
2685  {
2686  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2687  nativeLabel = nativeLabelStackBytes;
2688  }
2689 
2690  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2691  nativeLabel[nativeLabelOffset] = 0;
2692  }
2693  else
2694  {
2695  nativeLabel = null;
2696  }
2697 
2698  fixed (Vector3F* nativeCol = &col)
2699  {
2700  byte ret = ImGuiNative.igColorPicker3(nativeLabel, nativeCol, flags);
2701  if (labelByteCount > Util.StackAllocationSizeLimit)
2702  {
2703  Util.Free(nativeLabel);
2704  }
2705 
2706  return ret != 0;
2707  }
2708  }
2709 
2716  public static bool ColorPicker4(string label, ref Vector4F col)
2717  {
2718  byte* nativeLabel;
2719  int labelByteCount = 0;
2720  if (label != null)
2721  {
2722  labelByteCount = Encoding.UTF8.GetByteCount(label);
2723  if (labelByteCount > Util.StackAllocationSizeLimit)
2724  {
2725  nativeLabel = Util.Allocate(labelByteCount + 1);
2726  }
2727  else
2728  {
2729  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2730  nativeLabel = nativeLabelStackBytes;
2731  }
2732 
2733  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2734  nativeLabel[nativeLabelOffset] = 0;
2735  }
2736  else
2737  {
2738  nativeLabel = null;
2739  }
2740 
2741  ImGuiColorEditFlags flags = 0;
2742  float* refCol = null;
2743  fixed (Vector4F* nativeCol = &col)
2744  {
2745  byte ret = ImGuiNative.igColorPicker4(nativeLabel, nativeCol, flags, refCol);
2746  if (labelByteCount > Util.StackAllocationSizeLimit)
2747  {
2748  Util.Free(nativeLabel);
2749  }
2750 
2751  return ret != 0;
2752  }
2753  }
2754 
2762  public static bool ColorPicker4(string label, ref Vector4F col, ImGuiColorEditFlags flags)
2763  {
2764  byte* nativeLabel;
2765  int labelByteCount = 0;
2766  if (label != null)
2767  {
2768  labelByteCount = Encoding.UTF8.GetByteCount(label);
2769  if (labelByteCount > Util.StackAllocationSizeLimit)
2770  {
2771  nativeLabel = Util.Allocate(labelByteCount + 1);
2772  }
2773  else
2774  {
2775  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2776  nativeLabel = nativeLabelStackBytes;
2777  }
2778 
2779  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2780  nativeLabel[nativeLabelOffset] = 0;
2781  }
2782  else
2783  {
2784  nativeLabel = null;
2785  }
2786 
2787  float* refCol = null;
2788  fixed (Vector4F* nativeCol = &col)
2789  {
2790  byte ret = ImGuiNative.igColorPicker4(nativeLabel, nativeCol, flags, refCol);
2791  if (labelByteCount > Util.StackAllocationSizeLimit)
2792  {
2793  Util.Free(nativeLabel);
2794  }
2795 
2796  return ret != 0;
2797  }
2798  }
2799 
2808  public static bool ColorPicker4(string label, ref Vector4F col, ImGuiColorEditFlags flags, ref float refCol)
2809  {
2810  byte* nativeLabel;
2811  int labelByteCount = 0;
2812  if (label != null)
2813  {
2814  labelByteCount = Encoding.UTF8.GetByteCount(label);
2815  if (labelByteCount > Util.StackAllocationSizeLimit)
2816  {
2817  nativeLabel = Util.Allocate(labelByteCount + 1);
2818  }
2819  else
2820  {
2821  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2822  nativeLabel = nativeLabelStackBytes;
2823  }
2824 
2825  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2826  nativeLabel[nativeLabelOffset] = 0;
2827  }
2828  else
2829  {
2830  nativeLabel = null;
2831  }
2832 
2833  fixed (Vector4F* nativeCol = &col)
2834  {
2835  fixed (float* nativeRefCol = &refCol)
2836  {
2837  byte ret = ImGuiNative.igColorPicker4(nativeLabel, nativeCol, flags, nativeRefCol);
2838  if (labelByteCount > Util.StackAllocationSizeLimit)
2839  {
2840  Util.Free(nativeLabel);
2841  }
2842 
2843  return ret != 0;
2844  }
2845  }
2846  }
2847 
2851  public static void Columns()
2852  {
2853  int count = 1;
2854  byte* nativeId = null;
2855  byte border = 1;
2856  ImGuiNative.igColumns(count, nativeId, border);
2857  }
2858 
2863  public static void Columns(int count)
2864  {
2865  byte* nativeId = null;
2866  byte border = 1;
2867  ImGuiNative.igColumns(count, nativeId, border);
2868  }
2869 
2875  public static void Columns(int count, string id)
2876  {
2877  byte* nativeId;
2878  int idByteCount = 0;
2879  if (id != null)
2880  {
2881  idByteCount = Encoding.UTF8.GetByteCount(id);
2882  if (idByteCount > Util.StackAllocationSizeLimit)
2883  {
2884  nativeId = Util.Allocate(idByteCount + 1);
2885  }
2886  else
2887  {
2888  byte* nativeIdStackBytes = stackalloc byte[idByteCount + 1];
2889  nativeId = nativeIdStackBytes;
2890  }
2891 
2892  int nativeIdOffset = Util.GetUtf8(id, nativeId, idByteCount);
2893  nativeId[nativeIdOffset] = 0;
2894  }
2895  else
2896  {
2897  nativeId = null;
2898  }
2899 
2900  byte border = 1;
2901  ImGuiNative.igColumns(count, nativeId, border);
2902  if (idByteCount > Util.StackAllocationSizeLimit)
2903  {
2904  Util.Free(nativeId);
2905  }
2906  }
2907 
2914  public static void Columns(int count, string id, bool border)
2915  {
2916  byte* nativeId;
2917  int idByteCount = 0;
2918  if (id != null)
2919  {
2920  idByteCount = Encoding.UTF8.GetByteCount(id);
2921  if (idByteCount > Util.StackAllocationSizeLimit)
2922  {
2923  nativeId = Util.Allocate(idByteCount + 1);
2924  }
2925  else
2926  {
2927  byte* nativeIdStackBytes = stackalloc byte[idByteCount + 1];
2928  nativeId = nativeIdStackBytes;
2929  }
2930 
2931  int nativeIdOffset = Util.GetUtf8(id, nativeId, idByteCount);
2932  nativeId[nativeIdOffset] = 0;
2933  }
2934  else
2935  {
2936  nativeId = null;
2937  }
2938 
2939  byte nativeBorder = border ? (byte) 1 : (byte) 0;
2940  ImGuiNative.igColumns(count, nativeId, nativeBorder);
2941  if (idByteCount > Util.StackAllocationSizeLimit)
2942  {
2943  Util.Free(nativeId);
2944  }
2945  }
2946 
2955  public static bool Combo(string label, ref int currentItem, string[] items, int itemsCount)
2956  {
2957  byte* nativeLabel;
2958  int labelByteCount = 0;
2959  if (label != null)
2960  {
2961  labelByteCount = Encoding.UTF8.GetByteCount(label);
2962  if (labelByteCount > Util.StackAllocationSizeLimit)
2963  {
2964  nativeLabel = Util.Allocate(labelByteCount + 1);
2965  }
2966  else
2967  {
2968  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2969  nativeLabel = nativeLabelStackBytes;
2970  }
2971 
2972  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2973  nativeLabel[nativeLabelOffset] = 0;
2974  }
2975  else
2976  {
2977  nativeLabel = null;
2978  }
2979 
2980  int* itemsByteCounts = stackalloc int[items.Length];
2981  int itemsByteCount = 0;
2982  for (int i = 0; i < items.Length; i++)
2983  {
2984  string s = items[i];
2985  itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
2986  itemsByteCount += itemsByteCounts[i] + 1;
2987  }
2988 
2989  byte* nativeItemsData = stackalloc byte[itemsByteCount];
2990  int offset = 0;
2991  for (int i = 0; i < items.Length; i++)
2992  {
2993  string s = items[i];
2994  fixed (char* sPtr = s)
2995  {
2996  offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
2997  nativeItemsData[offset] = 0;
2998  offset += 1;
2999  }
3000  }
3001 
3002  byte** nativeItems = stackalloc byte*[items.Length];
3003  offset = 0;
3004  for (int i = 0; i < items.Length; i++)
3005  {
3006  nativeItems[i] = &nativeItemsData[offset];
3007  offset += itemsByteCounts[i] + 1;
3008  }
3009 
3010  int popupMaxHeightInItems = -1;
3011  fixed (int* nativeCurrentItem = &currentItem)
3012  {
3013  byte ret = ImGuiNative.igCombo_Str_arr(nativeLabel, nativeCurrentItem, nativeItems, itemsCount, popupMaxHeightInItems);
3014  if (labelByteCount > Util.StackAllocationSizeLimit)
3015  {
3016  Util.Free(nativeLabel);
3017  }
3018 
3019  return ret != 0;
3020  }
3021  }
3022 
3032  public static bool Combo(string label, ref int currentItem, string[] items, int itemsCount, int popupMaxHeightInItems)
3033  {
3034  byte* nativeLabel;
3035  int labelByteCount = 0;
3036  if (label != null)
3037  {
3038  labelByteCount = Encoding.UTF8.GetByteCount(label);
3039  if (labelByteCount > Util.StackAllocationSizeLimit)
3040  {
3041  nativeLabel = Util.Allocate(labelByteCount + 1);
3042  }
3043  else
3044  {
3045  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3046  nativeLabel = nativeLabelStackBytes;
3047  }
3048 
3049  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3050  nativeLabel[nativeLabelOffset] = 0;
3051  }
3052  else
3053  {
3054  nativeLabel = null;
3055  }
3056 
3057  int* itemsByteCounts = stackalloc int[items.Length];
3058  int itemsByteCount = 0;
3059  for (int i = 0; i < items.Length; i++)
3060  {
3061  string s = items[i];
3062  itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
3063  itemsByteCount += itemsByteCounts[i] + 1;
3064  }
3065 
3066  byte* nativeItemsData = stackalloc byte[itemsByteCount];
3067  int offset = 0;
3068  for (int i = 0; i < items.Length; i++)
3069  {
3070  string s = items[i];
3071  fixed (char* sPtr = s)
3072  {
3073  offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
3074  nativeItemsData[offset] = 0;
3075  offset += 1;
3076  }
3077  }
3078 
3079  byte** nativeItems = stackalloc byte*[items.Length];
3080  offset = 0;
3081  for (int i = 0; i < items.Length; i++)
3082  {
3083  nativeItems[i] = &nativeItemsData[offset];
3084  offset += itemsByteCounts[i] + 1;
3085  }
3086 
3087  fixed (int* nativeCurrentItem = &currentItem)
3088  {
3089  byte ret = ImGuiNative.igCombo_Str_arr(nativeLabel, nativeCurrentItem, nativeItems, itemsCount, popupMaxHeightInItems);
3090  if (labelByteCount > Util.StackAllocationSizeLimit)
3091  {
3092  Util.Free(nativeLabel);
3093  }
3094 
3095  return ret != 0;
3096  }
3097  }
3098 
3106  public static bool Combo(string label, ref int currentItem, string itemsSeparatedByZeros)
3107  {
3108  byte* nativeLabel;
3109  int labelByteCount = 0;
3110  if (label != null)
3111  {
3112  labelByteCount = Encoding.UTF8.GetByteCount(label);
3113  if (labelByteCount > Util.StackAllocationSizeLimit)
3114  {
3115  nativeLabel = Util.Allocate(labelByteCount + 1);
3116  }
3117  else
3118  {
3119  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3120  nativeLabel = nativeLabelStackBytes;
3121  }
3122 
3123  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3124  nativeLabel[nativeLabelOffset] = 0;
3125  }
3126  else
3127  {
3128  nativeLabel = null;
3129  }
3130 
3131  byte* nativeItemsSeparatedByZeros;
3132  int itemsSeparatedByZerosByteCount = 0;
3133  if (itemsSeparatedByZeros != null)
3134  {
3135  itemsSeparatedByZerosByteCount = Encoding.UTF8.GetByteCount(itemsSeparatedByZeros);
3136  if (itemsSeparatedByZerosByteCount > Util.StackAllocationSizeLimit)
3137  {
3138  nativeItemsSeparatedByZeros = Util.Allocate(itemsSeparatedByZerosByteCount + 1);
3139  }
3140  else
3141  {
3142  byte* nativeItemsSeparatedByZerosStackBytes = stackalloc byte[itemsSeparatedByZerosByteCount + 1];
3143  nativeItemsSeparatedByZeros = nativeItemsSeparatedByZerosStackBytes;
3144  }
3145 
3146  int nativeItemsSeparatedByZerosOffset = Util.GetUtf8(itemsSeparatedByZeros, nativeItemsSeparatedByZeros, itemsSeparatedByZerosByteCount);
3147  nativeItemsSeparatedByZeros[nativeItemsSeparatedByZerosOffset] = 0;
3148  }
3149  else
3150  {
3151  nativeItemsSeparatedByZeros = null;
3152  }
3153 
3154  int popupMaxHeightInItems = -1;
3155  fixed (int* nativeCurrentItem = &currentItem)
3156  {
3157  byte ret = ImGuiNative.igCombo_Str(nativeLabel, nativeCurrentItem, nativeItemsSeparatedByZeros, popupMaxHeightInItems);
3158  if (labelByteCount > Util.StackAllocationSizeLimit)
3159  {
3160  Util.Free(nativeLabel);
3161  }
3162 
3163  if (itemsSeparatedByZerosByteCount > Util.StackAllocationSizeLimit)
3164  {
3165  Util.Free(nativeItemsSeparatedByZeros);
3166  }
3167 
3168  return ret != 0;
3169  }
3170  }
3171 
3180  public static bool Combo(string label, ref int currentItem, string itemsSeparatedByZeros, int popupMaxHeightInItems)
3181  {
3182  byte* nativeLabel;
3183  int labelByteCount = 0;
3184  if (label != null)
3185  {
3186  labelByteCount = Encoding.UTF8.GetByteCount(label);
3187  if (labelByteCount > Util.StackAllocationSizeLimit)
3188  {
3189  nativeLabel = Util.Allocate(labelByteCount + 1);
3190  }
3191  else
3192  {
3193  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3194  nativeLabel = nativeLabelStackBytes;
3195  }
3196 
3197  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3198  nativeLabel[nativeLabelOffset] = 0;
3199  }
3200  else
3201  {
3202  nativeLabel = null;
3203  }
3204 
3205  byte* nativeItemsSeparatedByZeros;
3206  int itemsSeparatedByZerosByteCount = 0;
3207  if (itemsSeparatedByZeros != null)
3208  {
3209  itemsSeparatedByZerosByteCount = Encoding.UTF8.GetByteCount(itemsSeparatedByZeros);
3210  if (itemsSeparatedByZerosByteCount > Util.StackAllocationSizeLimit)
3211  {
3212  nativeItemsSeparatedByZeros = Util.Allocate(itemsSeparatedByZerosByteCount + 1);
3213  }
3214  else
3215  {
3216  byte* nativeItemsSeparatedByZerosStackBytes = stackalloc byte[itemsSeparatedByZerosByteCount + 1];
3217  nativeItemsSeparatedByZeros = nativeItemsSeparatedByZerosStackBytes;
3218  }
3219 
3220  int nativeItemsSeparatedByZerosOffset = Util.GetUtf8(itemsSeparatedByZeros, nativeItemsSeparatedByZeros, itemsSeparatedByZerosByteCount);
3221  nativeItemsSeparatedByZeros[nativeItemsSeparatedByZerosOffset] = 0;
3222  }
3223  else
3224  {
3225  nativeItemsSeparatedByZeros = null;
3226  }
3227 
3228  fixed (int* nativeCurrentItem = &currentItem)
3229  {
3230  byte ret = ImGuiNative.igCombo_Str(nativeLabel, nativeCurrentItem, nativeItemsSeparatedByZeros, popupMaxHeightInItems);
3231  if (labelByteCount > Util.StackAllocationSizeLimit)
3232  {
3233  Util.Free(nativeLabel);
3234  }
3235 
3236  if (itemsSeparatedByZerosByteCount > Util.StackAllocationSizeLimit)
3237  {
3238  Util.Free(nativeItemsSeparatedByZeros);
3239  }
3240 
3241  return ret != 0;
3242  }
3243  }
3244 
3249  public static IntPtr CreateContext()
3250  {
3251  ImFontAtlas* sharedFontAtlas = null;
3252  IntPtr ret = ImGuiNative.igCreateContext(sharedFontAtlas);
3253  return ret;
3254  }
3255 
3261  public static IntPtr CreateContext(ImFontAtlasPtr sharedFontAtlas)
3262  {
3263  ImFontAtlas* nativeSharedFontAtlas = sharedFontAtlas.NativePtr;
3264  IntPtr ret = ImGuiNative.igCreateContext(nativeSharedFontAtlas);
3265  return ret;
3266  }
3267 
3279  public static bool DebugCheckVersionAndDataLayout(string versionStr, uint szIo, uint szStyle, uint szVec2, uint szVec4, uint szDrawvert, uint szDrawidx)
3280  {
3281  byte* nativeVersionStr;
3282  int versionStrByteCount = 0;
3283  if (versionStr != null)
3284  {
3285  versionStrByteCount = Encoding.UTF8.GetByteCount(versionStr);
3286  if (versionStrByteCount > Util.StackAllocationSizeLimit)
3287  {
3288  nativeVersionStr = Util.Allocate(versionStrByteCount + 1);
3289  }
3290  else
3291  {
3292  byte* nativeVersionStrStackBytes = stackalloc byte[versionStrByteCount + 1];
3293  nativeVersionStr = nativeVersionStrStackBytes;
3294  }
3295 
3296  int nativeVersionStrOffset = Util.GetUtf8(versionStr, nativeVersionStr, versionStrByteCount);
3297  nativeVersionStr[nativeVersionStrOffset] = 0;
3298  }
3299  else
3300  {
3301  nativeVersionStr = null;
3302  }
3303 
3304  byte ret = ImGuiNative.igDebugCheckVersionAndDataLayout(nativeVersionStr, szIo, szStyle, szVec2, szVec4, szDrawvert, szDrawidx);
3305  if (versionStrByteCount > Util.StackAllocationSizeLimit)
3306  {
3307  Util.Free(nativeVersionStr);
3308  }
3309 
3310  return ret != 0;
3311  }
3312 
3317  public static void DebugTextEncoding(string text)
3318  {
3319  byte* nativeText;
3320  int textByteCount = 0;
3321  if (text != null)
3322  {
3323  textByteCount = Encoding.UTF8.GetByteCount(text);
3324  if (textByteCount > Util.StackAllocationSizeLimit)
3325  {
3326  nativeText = Util.Allocate(textByteCount + 1);
3327  }
3328  else
3329  {
3330  byte* nativeTextStackBytes = stackalloc byte[textByteCount + 1];
3331  nativeText = nativeTextStackBytes;
3332  }
3333 
3334  int nativeTextOffset = Util.GetUtf8(text, nativeText, textByteCount);
3335  nativeText[nativeTextOffset] = 0;
3336  }
3337  else
3338  {
3339  nativeText = null;
3340  }
3341 
3342  ImGuiNative.igDebugTextEncoding(nativeText);
3343  if (textByteCount > Util.StackAllocationSizeLimit)
3344  {
3345  Util.Free(nativeText);
3346  }
3347  }
3348 
3352  public static void DestroyContext()
3353  {
3354  IntPtr ctx = IntPtr.Zero;
3355  ImGuiNative.igDestroyContext(ctx);
3356  }
3357 
3362  public static void DestroyContext(IntPtr ctx)
3363  {
3364  ImGuiNative.igDestroyContext(ctx);
3365  }
3366 
3370  public static void DestroyPlatformWindows()
3371  {
3372  ImGuiNative.igDestroyPlatformWindows();
3373  }
3374 
3380  public static uint DockSpace(uint id)
3381  {
3382  Vector2F size = new Vector2F();
3383  ImGuiDockNodeFlags flags = 0;
3384  ImGuiWindowClass* windowClass = null;
3385  uint ret = ImGuiNative.igDockSpace(id, size, flags, windowClass);
3386  return ret;
3387  }
3388 
3395  public static uint DockSpace(uint id, Vector2F size)
3396  {
3397  ImGuiDockNodeFlags flags = 0;
3398  ImGuiWindowClass* windowClass = null;
3399  uint ret = ImGuiNative.igDockSpace(id, size, flags, windowClass);
3400  return ret;
3401  }
3402 
3410  public static uint DockSpace(uint id, Vector2F size, ImGuiDockNodeFlags flags)
3411  {
3412  ImGuiWindowClass* windowClass = null;
3413  uint ret = ImGuiNative.igDockSpace(id, size, flags, windowClass);
3414  return ret;
3415  }
3416 
3425  public static uint DockSpace(uint id, Vector2F size, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
3426  {
3427  ImGuiWindowClass* nativeWindowClass = windowClass.NativePtr;
3428  uint ret = ImGuiNative.igDockSpace(id, size, flags, nativeWindowClass);
3429  return ret;
3430  }
3431 
3436  public static uint DockSpaceOverViewport()
3437  {
3438  ImGuiViewport* viewport = null;
3439  ImGuiDockNodeFlags flags = 0;
3440  ImGuiWindowClass* windowClass = null;
3441  uint ret = ImGuiNative.igDockSpaceOverViewport(viewport, flags, windowClass);
3442  return ret;
3443  }
3444 
3450  public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport)
3451  {
3452  ImGuiViewport* nativeViewport = viewport.NativePtr;
3453  ImGuiDockNodeFlags flags = 0;
3454  ImGuiWindowClass* windowClass = null;
3455  uint ret = ImGuiNative.igDockSpaceOverViewport(nativeViewport, flags, windowClass);
3456  return ret;
3457  }
3458 
3465  public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags)
3466  {
3467  ImGuiViewport* nativeViewport = viewport.NativePtr;
3468  ImGuiWindowClass* windowClass = null;
3469  uint ret = ImGuiNative.igDockSpaceOverViewport(nativeViewport, flags, windowClass);
3470  return ret;
3471  }
3472 
3480  public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
3481  {
3482  ImGuiViewport* nativeViewport = viewport.NativePtr;
3483  ImGuiWindowClass* nativeWindowClass = windowClass.NativePtr;
3484  uint ret = ImGuiNative.igDockSpaceOverViewport(nativeViewport, flags, nativeWindowClass);
3485  return ret;
3486  }
3487 
3494  public static bool DragFloat(string label, ref float v)
3495  {
3496  byte* nativeLabel;
3497  int labelByteCount = 0;
3498  if (label != null)
3499  {
3500  labelByteCount = Encoding.UTF8.GetByteCount(label);
3501  if (labelByteCount > Util.StackAllocationSizeLimit)
3502  {
3503  nativeLabel = Util.Allocate(labelByteCount + 1);
3504  }
3505  else
3506  {
3507  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3508  nativeLabel = nativeLabelStackBytes;
3509  }
3510 
3511  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3512  nativeLabel[nativeLabelOffset] = 0;
3513  }
3514  else
3515  {
3516  nativeLabel = null;
3517  }
3518 
3519  float vSpeed = 1.0f;
3520  float vMin = 0.0f;
3521  float vMax = 0.0f;
3522  byte* nativeFormat;
3523  int formatByteCount = 0;
3524  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3525  if (formatByteCount > Util.StackAllocationSizeLimit)
3526  {
3527  nativeFormat = Util.Allocate(formatByteCount + 1);
3528  }
3529  else
3530  {
3531  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3532  nativeFormat = nativeFormatStackBytes;
3533  }
3534 
3535  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3536  nativeFormat[nativeFormatOffset] = 0;
3537  ImGuiSliderFlags flags = 0;
3538  fixed (float* nativeV = &v)
3539  {
3540  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
3541  if (labelByteCount > Util.StackAllocationSizeLimit)
3542  {
3543  Util.Free(nativeLabel);
3544  }
3545 
3546  if (formatByteCount > Util.StackAllocationSizeLimit)
3547  {
3548  Util.Free(nativeFormat);
3549  }
3550 
3551  return ret != 0;
3552  }
3553  }
3554 
3562  public static bool DragFloat(string label, ref float v, float vSpeed)
3563  {
3564  byte* nativeLabel;
3565  int labelByteCount = 0;
3566  if (label != null)
3567  {
3568  labelByteCount = Encoding.UTF8.GetByteCount(label);
3569  if (labelByteCount > Util.StackAllocationSizeLimit)
3570  {
3571  nativeLabel = Util.Allocate(labelByteCount + 1);
3572  }
3573  else
3574  {
3575  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3576  nativeLabel = nativeLabelStackBytes;
3577  }
3578 
3579  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3580  nativeLabel[nativeLabelOffset] = 0;
3581  }
3582  else
3583  {
3584  nativeLabel = null;
3585  }
3586 
3587  float vMin = 0.0f;
3588  float vMax = 0.0f;
3589  byte* nativeFormat;
3590  int formatByteCount = 0;
3591  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3592  if (formatByteCount > Util.StackAllocationSizeLimit)
3593  {
3594  nativeFormat = Util.Allocate(formatByteCount + 1);
3595  }
3596  else
3597  {
3598  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3599  nativeFormat = nativeFormatStackBytes;
3600  }
3601 
3602  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3603  nativeFormat[nativeFormatOffset] = 0;
3604  ImGuiSliderFlags flags = 0;
3605  fixed (float* nativeV = &v)
3606  {
3607  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
3608  if (labelByteCount > Util.StackAllocationSizeLimit)
3609  {
3610  Util.Free(nativeLabel);
3611  }
3612 
3613  if (formatByteCount > Util.StackAllocationSizeLimit)
3614  {
3615  Util.Free(nativeFormat);
3616  }
3617 
3618  return ret != 0;
3619  }
3620  }
3621 
3630  public static bool DragFloat(string label, ref float v, float vSpeed, float vMin)
3631  {
3632  byte* nativeLabel;
3633  int labelByteCount = 0;
3634  if (label != null)
3635  {
3636  labelByteCount = Encoding.UTF8.GetByteCount(label);
3637  if (labelByteCount > Util.StackAllocationSizeLimit)
3638  {
3639  nativeLabel = Util.Allocate(labelByteCount + 1);
3640  }
3641  else
3642  {
3643  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3644  nativeLabel = nativeLabelStackBytes;
3645  }
3646 
3647  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3648  nativeLabel[nativeLabelOffset] = 0;
3649  }
3650  else
3651  {
3652  nativeLabel = null;
3653  }
3654 
3655  float vMax = 0.0f;
3656  byte* nativeFormat;
3657  int formatByteCount = 0;
3658  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3659  if (formatByteCount > Util.StackAllocationSizeLimit)
3660  {
3661  nativeFormat = Util.Allocate(formatByteCount + 1);
3662  }
3663  else
3664  {
3665  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3666  nativeFormat = nativeFormatStackBytes;
3667  }
3668 
3669  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3670  nativeFormat[nativeFormatOffset] = 0;
3671  ImGuiSliderFlags flags = 0;
3672  fixed (float* nativeV = &v)
3673  {
3674  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
3675  if (labelByteCount > Util.StackAllocationSizeLimit)
3676  {
3677  Util.Free(nativeLabel);
3678  }
3679 
3680  if (formatByteCount > Util.StackAllocationSizeLimit)
3681  {
3682  Util.Free(nativeFormat);
3683  }
3684 
3685  return ret != 0;
3686  }
3687  }
3688 
3698  public static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax)
3699  {
3700  byte* nativeLabel;
3701  int labelByteCount = 0;
3702  if (label != null)
3703  {
3704  labelByteCount = Encoding.UTF8.GetByteCount(label);
3705  if (labelByteCount > Util.StackAllocationSizeLimit)
3706  {
3707  nativeLabel = Util.Allocate(labelByteCount + 1);
3708  }
3709  else
3710  {
3711  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3712  nativeLabel = nativeLabelStackBytes;
3713  }
3714 
3715  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3716  nativeLabel[nativeLabelOffset] = 0;
3717  }
3718  else
3719  {
3720  nativeLabel = null;
3721  }
3722 
3723  byte* nativeFormat;
3724  int formatByteCount = 0;
3725  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3726  if (formatByteCount > Util.StackAllocationSizeLimit)
3727  {
3728  nativeFormat = Util.Allocate(formatByteCount + 1);
3729  }
3730  else
3731  {
3732  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3733  nativeFormat = nativeFormatStackBytes;
3734  }
3735 
3736  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3737  nativeFormat[nativeFormatOffset] = 0;
3738  ImGuiSliderFlags flags = 0;
3739  fixed (float* nativeV = &v)
3740  {
3741  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
3742  if (labelByteCount > Util.StackAllocationSizeLimit)
3743  {
3744  Util.Free(nativeLabel);
3745  }
3746 
3747  if (formatByteCount > Util.StackAllocationSizeLimit)
3748  {
3749  Util.Free(nativeFormat);
3750  }
3751 
3752  return ret != 0;
3753  }
3754  }
3755 
3766  public static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax, string format)
3767  {
3768  byte* nativeLabel;
3769  int labelByteCount = 0;
3770  if (label != null)
3771  {
3772  labelByteCount = Encoding.UTF8.GetByteCount(label);
3773  if (labelByteCount > Util.StackAllocationSizeLimit)
3774  {
3775  nativeLabel = Util.Allocate(labelByteCount + 1);
3776  }
3777  else
3778  {
3779  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3780  nativeLabel = nativeLabelStackBytes;
3781  }
3782 
3783  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3784  nativeLabel[nativeLabelOffset] = 0;
3785  }
3786  else
3787  {
3788  nativeLabel = null;
3789  }
3790 
3791  byte* nativeFormat;
3792  int formatByteCount = 0;
3793  if (format != null)
3794  {
3795  formatByteCount = Encoding.UTF8.GetByteCount(format);
3796  if (formatByteCount > Util.StackAllocationSizeLimit)
3797  {
3798  nativeFormat = Util.Allocate(formatByteCount + 1);
3799  }
3800  else
3801  {
3802  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3803  nativeFormat = nativeFormatStackBytes;
3804  }
3805 
3806  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
3807  nativeFormat[nativeFormatOffset] = 0;
3808  }
3809  else
3810  {
3811  nativeFormat = null;
3812  }
3813 
3814  ImGuiSliderFlags flags = 0;
3815  fixed (float* nativeV = &v)
3816  {
3817  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
3818  if (labelByteCount > Util.StackAllocationSizeLimit)
3819  {
3820  Util.Free(nativeLabel);
3821  }
3822 
3823  if (formatByteCount > Util.StackAllocationSizeLimit)
3824  {
3825  Util.Free(nativeFormat);
3826  }
3827 
3828  return ret != 0;
3829  }
3830  }
3831 
3843  public static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax, string format, ImGuiSliderFlags flags)
3844  {
3845  byte* nativeLabel;
3846  int labelByteCount = 0;
3847  if (label != null)
3848  {
3849  labelByteCount = Encoding.UTF8.GetByteCount(label);
3850  if (labelByteCount > Util.StackAllocationSizeLimit)
3851  {
3852  nativeLabel = Util.Allocate(labelByteCount + 1);
3853  }
3854  else
3855  {
3856  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3857  nativeLabel = nativeLabelStackBytes;
3858  }
3859 
3860  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3861  nativeLabel[nativeLabelOffset] = 0;
3862  }
3863  else
3864  {
3865  nativeLabel = null;
3866  }
3867 
3868  byte* nativeFormat;
3869  int formatByteCount = 0;
3870  if (format != null)
3871  {
3872  formatByteCount = Encoding.UTF8.GetByteCount(format);
3873  if (formatByteCount > Util.StackAllocationSizeLimit)
3874  {
3875  nativeFormat = Util.Allocate(formatByteCount + 1);
3876  }
3877  else
3878  {
3879  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3880  nativeFormat = nativeFormatStackBytes;
3881  }
3882 
3883  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
3884  nativeFormat[nativeFormatOffset] = 0;
3885  }
3886  else
3887  {
3888  nativeFormat = null;
3889  }
3890 
3891  fixed (float* nativeV = &v)
3892  {
3893  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
3894  if (labelByteCount > Util.StackAllocationSizeLimit)
3895  {
3896  Util.Free(nativeLabel);
3897  }
3898 
3899  if (formatByteCount > Util.StackAllocationSizeLimit)
3900  {
3901  Util.Free(nativeFormat);
3902  }
3903 
3904  return ret != 0;
3905  }
3906  }
3907 
3914  public static bool DragFloat2(string label, ref Vector2F v)
3915  {
3916  byte* nativeLabel;
3917  int labelByteCount = 0;
3918  if (label != null)
3919  {
3920  labelByteCount = Encoding.UTF8.GetByteCount(label);
3921  if (labelByteCount > Util.StackAllocationSizeLimit)
3922  {
3923  nativeLabel = Util.Allocate(labelByteCount + 1);
3924  }
3925  else
3926  {
3927  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3928  nativeLabel = nativeLabelStackBytes;
3929  }
3930 
3931  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3932  nativeLabel[nativeLabelOffset] = 0;
3933  }
3934  else
3935  {
3936  nativeLabel = null;
3937  }
3938 
3939  float vSpeed = 1.0f;
3940  float vMin = 0.0f;
3941  float vMax = 0.0f;
3942  byte* nativeFormat;
3943  int formatByteCount = 0;
3944  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3945  if (formatByteCount > Util.StackAllocationSizeLimit)
3946  {
3947  nativeFormat = Util.Allocate(formatByteCount + 1);
3948  }
3949  else
3950  {
3951  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3952  nativeFormat = nativeFormatStackBytes;
3953  }
3954 
3955  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3956  nativeFormat[nativeFormatOffset] = 0;
3957  ImGuiSliderFlags flags = 0;
3958  fixed (Vector2F* nativeV = &v)
3959  {
3960  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
3961  if (labelByteCount > Util.StackAllocationSizeLimit)
3962  {
3963  Util.Free(nativeLabel);
3964  }
3965 
3966  if (formatByteCount > Util.StackAllocationSizeLimit)
3967  {
3968  Util.Free(nativeFormat);
3969  }
3970 
3971  return ret != 0;
3972  }
3973  }
3974 
3982  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed)
3983  {
3984  byte* nativeLabel;
3985  int labelByteCount = 0;
3986  if (label != null)
3987  {
3988  labelByteCount = Encoding.UTF8.GetByteCount(label);
3989  if (labelByteCount > Util.StackAllocationSizeLimit)
3990  {
3991  nativeLabel = Util.Allocate(labelByteCount + 1);
3992  }
3993  else
3994  {
3995  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3996  nativeLabel = nativeLabelStackBytes;
3997  }
3998 
3999  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4000  nativeLabel[nativeLabelOffset] = 0;
4001  }
4002  else
4003  {
4004  nativeLabel = null;
4005  }
4006 
4007  float vMin = 0.0f;
4008  float vMax = 0.0f;
4009  byte* nativeFormat;
4010  int formatByteCount = 0;
4011  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4012  if (formatByteCount > Util.StackAllocationSizeLimit)
4013  {
4014  nativeFormat = Util.Allocate(formatByteCount + 1);
4015  }
4016  else
4017  {
4018  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4019  nativeFormat = nativeFormatStackBytes;
4020  }
4021 
4022  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4023  nativeFormat[nativeFormatOffset] = 0;
4024  ImGuiSliderFlags flags = 0;
4025  fixed (Vector2F* nativeV = &v)
4026  {
4027  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4028  if (labelByteCount > Util.StackAllocationSizeLimit)
4029  {
4030  Util.Free(nativeLabel);
4031  }
4032 
4033  if (formatByteCount > Util.StackAllocationSizeLimit)
4034  {
4035  Util.Free(nativeFormat);
4036  }
4037 
4038  return ret != 0;
4039  }
4040  }
4041 
4050  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin)
4051  {
4052  byte* nativeLabel;
4053  int labelByteCount = 0;
4054  if (label != null)
4055  {
4056  labelByteCount = Encoding.UTF8.GetByteCount(label);
4057  if (labelByteCount > Util.StackAllocationSizeLimit)
4058  {
4059  nativeLabel = Util.Allocate(labelByteCount + 1);
4060  }
4061  else
4062  {
4063  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4064  nativeLabel = nativeLabelStackBytes;
4065  }
4066 
4067  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4068  nativeLabel[nativeLabelOffset] = 0;
4069  }
4070  else
4071  {
4072  nativeLabel = null;
4073  }
4074 
4075  float vMax = 0.0f;
4076  byte* nativeFormat;
4077  int formatByteCount = 0;
4078  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4079  if (formatByteCount > Util.StackAllocationSizeLimit)
4080  {
4081  nativeFormat = Util.Allocate(formatByteCount + 1);
4082  }
4083  else
4084  {
4085  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4086  nativeFormat = nativeFormatStackBytes;
4087  }
4088 
4089  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4090  nativeFormat[nativeFormatOffset] = 0;
4091  ImGuiSliderFlags flags = 0;
4092  fixed (Vector2F* nativeV = &v)
4093  {
4094  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4095  if (labelByteCount > Util.StackAllocationSizeLimit)
4096  {
4097  Util.Free(nativeLabel);
4098  }
4099 
4100  if (formatByteCount > Util.StackAllocationSizeLimit)
4101  {
4102  Util.Free(nativeFormat);
4103  }
4104 
4105  return ret != 0;
4106  }
4107  }
4108 
4118  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax)
4119  {
4120  byte* nativeLabel;
4121  int labelByteCount = 0;
4122  if (label != null)
4123  {
4124  labelByteCount = Encoding.UTF8.GetByteCount(label);
4125  if (labelByteCount > Util.StackAllocationSizeLimit)
4126  {
4127  nativeLabel = Util.Allocate(labelByteCount + 1);
4128  }
4129  else
4130  {
4131  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4132  nativeLabel = nativeLabelStackBytes;
4133  }
4134 
4135  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4136  nativeLabel[nativeLabelOffset] = 0;
4137  }
4138  else
4139  {
4140  nativeLabel = null;
4141  }
4142 
4143  byte* nativeFormat;
4144  int formatByteCount = 0;
4145  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4146  if (formatByteCount > Util.StackAllocationSizeLimit)
4147  {
4148  nativeFormat = Util.Allocate(formatByteCount + 1);
4149  }
4150  else
4151  {
4152  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4153  nativeFormat = nativeFormatStackBytes;
4154  }
4155 
4156  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4157  nativeFormat[nativeFormatOffset] = 0;
4158  ImGuiSliderFlags flags = 0;
4159  fixed (Vector2F* nativeV = &v)
4160  {
4161  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4162  if (labelByteCount > Util.StackAllocationSizeLimit)
4163  {
4164  Util.Free(nativeLabel);
4165  }
4166 
4167  if (formatByteCount > Util.StackAllocationSizeLimit)
4168  {
4169  Util.Free(nativeFormat);
4170  }
4171 
4172  return ret != 0;
4173  }
4174  }
4175 
4186  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax, string format)
4187  {
4188  byte* nativeLabel;
4189  int labelByteCount = 0;
4190  if (label != null)
4191  {
4192  labelByteCount = Encoding.UTF8.GetByteCount(label);
4193  if (labelByteCount > Util.StackAllocationSizeLimit)
4194  {
4195  nativeLabel = Util.Allocate(labelByteCount + 1);
4196  }
4197  else
4198  {
4199  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4200  nativeLabel = nativeLabelStackBytes;
4201  }
4202 
4203  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4204  nativeLabel[nativeLabelOffset] = 0;
4205  }
4206  else
4207  {
4208  nativeLabel = null;
4209  }
4210 
4211  byte* nativeFormat;
4212  int formatByteCount = 0;
4213  if (format != null)
4214  {
4215  formatByteCount = Encoding.UTF8.GetByteCount(format);
4216  if (formatByteCount > Util.StackAllocationSizeLimit)
4217  {
4218  nativeFormat = Util.Allocate(formatByteCount + 1);
4219  }
4220  else
4221  {
4222  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4223  nativeFormat = nativeFormatStackBytes;
4224  }
4225 
4226  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
4227  nativeFormat[nativeFormatOffset] = 0;
4228  }
4229  else
4230  {
4231  nativeFormat = null;
4232  }
4233 
4234  ImGuiSliderFlags flags = 0;
4235  fixed (Vector2F* nativeV = &v)
4236  {
4237  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4238  if (labelByteCount > Util.StackAllocationSizeLimit)
4239  {
4240  Util.Free(nativeLabel);
4241  }
4242 
4243  if (formatByteCount > Util.StackAllocationSizeLimit)
4244  {
4245  Util.Free(nativeFormat);
4246  }
4247 
4248  return ret != 0;
4249  }
4250  }
4251 
4263  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliderFlags flags)
4264  {
4265  byte* nativeLabel;
4266  int labelByteCount = 0;
4267  if (label != null)
4268  {
4269  labelByteCount = Encoding.UTF8.GetByteCount(label);
4270  if (labelByteCount > Util.StackAllocationSizeLimit)
4271  {
4272  nativeLabel = Util.Allocate(labelByteCount + 1);
4273  }
4274  else
4275  {
4276  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4277  nativeLabel = nativeLabelStackBytes;
4278  }
4279 
4280  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4281  nativeLabel[nativeLabelOffset] = 0;
4282  }
4283  else
4284  {
4285  nativeLabel = null;
4286  }
4287 
4288  byte* nativeFormat;
4289  int formatByteCount = 0;
4290  if (format != null)
4291  {
4292  formatByteCount = Encoding.UTF8.GetByteCount(format);
4293  if (formatByteCount > Util.StackAllocationSizeLimit)
4294  {
4295  nativeFormat = Util.Allocate(formatByteCount + 1);
4296  }
4297  else
4298  {
4299  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4300  nativeFormat = nativeFormatStackBytes;
4301  }
4302 
4303  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
4304  nativeFormat[nativeFormatOffset] = 0;
4305  }
4306  else
4307  {
4308  nativeFormat = null;
4309  }
4310 
4311  fixed (Vector2F* nativeV = &v)
4312  {
4313  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4314  if (labelByteCount > Util.StackAllocationSizeLimit)
4315  {
4316  Util.Free(nativeLabel);
4317  }
4318 
4319  if (formatByteCount > Util.StackAllocationSizeLimit)
4320  {
4321  Util.Free(nativeFormat);
4322  }
4323 
4324  return ret != 0;
4325  }
4326  }
4327 
4334  public static bool DragFloat3(string label, ref Vector3F v)
4335  {
4336  byte* nativeLabel;
4337  int labelByteCount = 0;
4338  if (label != null)
4339  {
4340  labelByteCount = Encoding.UTF8.GetByteCount(label);
4341  if (labelByteCount > Util.StackAllocationSizeLimit)
4342  {
4343  nativeLabel = Util.Allocate(labelByteCount + 1);
4344  }
4345  else
4346  {
4347  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4348  nativeLabel = nativeLabelStackBytes;
4349  }
4350 
4351  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4352  nativeLabel[nativeLabelOffset] = 0;
4353  }
4354  else
4355  {
4356  nativeLabel = null;
4357  }
4358 
4359  float vSpeed = 1.0f;
4360  float vMin = 0.0f;
4361  float vMax = 0.0f;
4362  byte* nativeFormat;
4363  int formatByteCount = 0;
4364  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4365  if (formatByteCount > Util.StackAllocationSizeLimit)
4366  {
4367  nativeFormat = Util.Allocate(formatByteCount + 1);
4368  }
4369  else
4370  {
4371  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4372  nativeFormat = nativeFormatStackBytes;
4373  }
4374 
4375  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4376  nativeFormat[nativeFormatOffset] = 0;
4377  ImGuiSliderFlags flags = 0;
4378  fixed (Vector3F* nativeV = &v)
4379  {
4380  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4381  if (labelByteCount > Util.StackAllocationSizeLimit)
4382  {
4383  Util.Free(nativeLabel);
4384  }
4385 
4386  if (formatByteCount > Util.StackAllocationSizeLimit)
4387  {
4388  Util.Free(nativeFormat);
4389  }
4390 
4391  return ret != 0;
4392  }
4393  }
4394 
4402  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed)
4403  {
4404  byte* nativeLabel;
4405  int labelByteCount = 0;
4406  if (label != null)
4407  {
4408  labelByteCount = Encoding.UTF8.GetByteCount(label);
4409  if (labelByteCount > Util.StackAllocationSizeLimit)
4410  {
4411  nativeLabel = Util.Allocate(labelByteCount + 1);
4412  }
4413  else
4414  {
4415  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4416  nativeLabel = nativeLabelStackBytes;
4417  }
4418 
4419  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4420  nativeLabel[nativeLabelOffset] = 0;
4421  }
4422  else
4423  {
4424  nativeLabel = null;
4425  }
4426 
4427  float vMin = 0.0f;
4428  float vMax = 0.0f;
4429  byte* nativeFormat;
4430  int formatByteCount = 0;
4431  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4432  if (formatByteCount > Util.StackAllocationSizeLimit)
4433  {
4434  nativeFormat = Util.Allocate(formatByteCount + 1);
4435  }
4436  else
4437  {
4438  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4439  nativeFormat = nativeFormatStackBytes;
4440  }
4441 
4442  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4443  nativeFormat[nativeFormatOffset] = 0;
4444  ImGuiSliderFlags flags = 0;
4445  fixed (Vector3F* nativeV = &v)
4446  {
4447  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4448  if (labelByteCount > Util.StackAllocationSizeLimit)
4449  {
4450  Util.Free(nativeLabel);
4451  }
4452 
4453  if (formatByteCount > Util.StackAllocationSizeLimit)
4454  {
4455  Util.Free(nativeFormat);
4456  }
4457 
4458  return ret != 0;
4459  }
4460  }
4461 
4470  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin)
4471  {
4472  byte* nativeLabel;
4473  int labelByteCount = 0;
4474  if (label != null)
4475  {
4476  labelByteCount = Encoding.UTF8.GetByteCount(label);
4477  if (labelByteCount > Util.StackAllocationSizeLimit)
4478  {
4479  nativeLabel = Util.Allocate(labelByteCount + 1);
4480  }
4481  else
4482  {
4483  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4484  nativeLabel = nativeLabelStackBytes;
4485  }
4486 
4487  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4488  nativeLabel[nativeLabelOffset] = 0;
4489  }
4490  else
4491  {
4492  nativeLabel = null;
4493  }
4494 
4495  float vMax = 0.0f;
4496  byte* nativeFormat;
4497  int formatByteCount = 0;
4498  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4499  if (formatByteCount > Util.StackAllocationSizeLimit)
4500  {
4501  nativeFormat = Util.Allocate(formatByteCount + 1);
4502  }
4503  else
4504  {
4505  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4506  nativeFormat = nativeFormatStackBytes;
4507  }
4508 
4509  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4510  nativeFormat[nativeFormatOffset] = 0;
4511  ImGuiSliderFlags flags = 0;
4512  fixed (Vector3F* nativeV = &v)
4513  {
4514  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4515  if (labelByteCount > Util.StackAllocationSizeLimit)
4516  {
4517  Util.Free(nativeLabel);
4518  }
4519 
4520  if (formatByteCount > Util.StackAllocationSizeLimit)
4521  {
4522  Util.Free(nativeFormat);
4523  }
4524 
4525  return ret != 0;
4526  }
4527  }
4528 
4538  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax)
4539  {
4540  byte* nativeLabel;
4541  int labelByteCount = 0;
4542  if (label != null)
4543  {
4544  labelByteCount = Encoding.UTF8.GetByteCount(label);
4545  if (labelByteCount > Util.StackAllocationSizeLimit)
4546  {
4547  nativeLabel = Util.Allocate(labelByteCount + 1);
4548  }
4549  else
4550  {
4551  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4552  nativeLabel = nativeLabelStackBytes;
4553  }
4554 
4555  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4556  nativeLabel[nativeLabelOffset] = 0;
4557  }
4558  else
4559  {
4560  nativeLabel = null;
4561  }
4562 
4563  byte* nativeFormat;
4564  int formatByteCount = 0;
4565  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4566  if (formatByteCount > Util.StackAllocationSizeLimit)
4567  {
4568  nativeFormat = Util.Allocate(formatByteCount + 1);
4569  }
4570  else
4571  {
4572  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4573  nativeFormat = nativeFormatStackBytes;
4574  }
4575 
4576  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4577  nativeFormat[nativeFormatOffset] = 0;
4578  ImGuiSliderFlags flags = 0;
4579  fixed (Vector3F* nativeV = &v)
4580  {
4581  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4582  if (labelByteCount > Util.StackAllocationSizeLimit)
4583  {
4584  Util.Free(nativeLabel);
4585  }
4586 
4587  if (formatByteCount > Util.StackAllocationSizeLimit)
4588  {
4589  Util.Free(nativeFormat);
4590  }
4591 
4592  return ret != 0;
4593  }
4594  }
4595 
4606  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax, string format)
4607  {
4608  byte* nativeLabel;
4609  int labelByteCount = 0;
4610  if (label != null)
4611  {
4612  labelByteCount = Encoding.UTF8.GetByteCount(label);
4613  if (labelByteCount > Util.StackAllocationSizeLimit)
4614  {
4615  nativeLabel = Util.Allocate(labelByteCount + 1);
4616  }
4617  else
4618  {
4619  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4620  nativeLabel = nativeLabelStackBytes;
4621  }
4622 
4623  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4624  nativeLabel[nativeLabelOffset] = 0;
4625  }
4626  else
4627  {
4628  nativeLabel = null;
4629  }
4630 
4631  byte* nativeFormat;
4632  int formatByteCount = 0;
4633  if (format != null)
4634  {
4635  formatByteCount = Encoding.UTF8.GetByteCount(format);
4636  if (formatByteCount > Util.StackAllocationSizeLimit)
4637  {
4638  nativeFormat = Util.Allocate(formatByteCount + 1);
4639  }
4640  else
4641  {
4642  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4643  nativeFormat = nativeFormatStackBytes;
4644  }
4645 
4646  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
4647  nativeFormat[nativeFormatOffset] = 0;
4648  }
4649  else
4650  {
4651  nativeFormat = null;
4652  }
4653 
4654  ImGuiSliderFlags flags = 0;
4655  fixed (Vector3F* nativeV = &v)
4656  {
4657  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4658  if (labelByteCount > Util.StackAllocationSizeLimit)
4659  {
4660  Util.Free(nativeLabel);
4661  }
4662 
4663  if (formatByteCount > Util.StackAllocationSizeLimit)
4664  {
4665  Util.Free(nativeFormat);
4666  }
4667 
4668  return ret != 0;
4669  }
4670  }
4671 
4683  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliderFlags flags)
4684  {
4685  byte* nativeLabel;
4686  int labelByteCount = 0;
4687  if (label != null)
4688  {
4689  labelByteCount = Encoding.UTF8.GetByteCount(label);
4690  if (labelByteCount > Util.StackAllocationSizeLimit)
4691  {
4692  nativeLabel = Util.Allocate(labelByteCount + 1);
4693  }
4694  else
4695  {
4696  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4697  nativeLabel = nativeLabelStackBytes;
4698  }
4699 
4700  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4701  nativeLabel[nativeLabelOffset] = 0;
4702  }
4703  else
4704  {
4705  nativeLabel = null;
4706  }
4707 
4708  byte* nativeFormat;
4709  int formatByteCount = 0;
4710  if (format != null)
4711  {
4712  formatByteCount = Encoding.UTF8.GetByteCount(format);
4713  if (formatByteCount > Util.StackAllocationSizeLimit)
4714  {
4715  nativeFormat = Util.Allocate(formatByteCount + 1);
4716  }
4717  else
4718  {
4719  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4720  nativeFormat = nativeFormatStackBytes;
4721  }
4722 
4723  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
4724  nativeFormat[nativeFormatOffset] = 0;
4725  }
4726  else
4727  {
4728  nativeFormat = null;
4729  }
4730 
4731  fixed (Vector3F* nativeV = &v)
4732  {
4733  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4734  if (labelByteCount > Util.StackAllocationSizeLimit)
4735  {
4736  Util.Free(nativeLabel);
4737  }
4738 
4739  if (formatByteCount > Util.StackAllocationSizeLimit)
4740  {
4741  Util.Free(nativeFormat);
4742  }
4743 
4744  return ret != 0;
4745  }
4746  }
4747 
4754  public static bool DragFloat4(string label, ref Vector4F v)
4755  {
4756  byte* nativeLabel;
4757  int labelByteCount = 0;
4758  if (label != null)
4759  {
4760  labelByteCount = Encoding.UTF8.GetByteCount(label);
4761  if (labelByteCount > Util.StackAllocationSizeLimit)
4762  {
4763  nativeLabel = Util.Allocate(labelByteCount + 1);
4764  }
4765  else
4766  {
4767  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4768  nativeLabel = nativeLabelStackBytes;
4769  }
4770 
4771  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4772  nativeLabel[nativeLabelOffset] = 0;
4773  }
4774  else
4775  {
4776  nativeLabel = null;
4777  }
4778 
4779  float vSpeed = 1.0f;
4780  float vMin = 0.0f;
4781  float vMax = 0.0f;
4782  byte* nativeFormat;
4783  int formatByteCount = 0;
4784  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4785  if (formatByteCount > Util.StackAllocationSizeLimit)
4786  {
4787  nativeFormat = Util.Allocate(formatByteCount + 1);
4788  }
4789  else
4790  {
4791  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4792  nativeFormat = nativeFormatStackBytes;
4793  }
4794 
4795  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4796  nativeFormat[nativeFormatOffset] = 0;
4797  ImGuiSliderFlags flags = 0;
4798  fixed (Vector4F* nativeV = &v)
4799  {
4800  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4801  if (labelByteCount > Util.StackAllocationSizeLimit)
4802  {
4803  Util.Free(nativeLabel);
4804  }
4805 
4806  if (formatByteCount > Util.StackAllocationSizeLimit)
4807  {
4808  Util.Free(nativeFormat);
4809  }
4810 
4811  return ret != 0;
4812  }
4813  }
4814 
4822  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed)
4823  {
4824  byte* nativeLabel;
4825  int labelByteCount = 0;
4826  if (label != null)
4827  {
4828  labelByteCount = Encoding.UTF8.GetByteCount(label);
4829  if (labelByteCount > Util.StackAllocationSizeLimit)
4830  {
4831  nativeLabel = Util.Allocate(labelByteCount + 1);
4832  }
4833  else
4834  {
4835  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4836  nativeLabel = nativeLabelStackBytes;
4837  }
4838 
4839  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4840  nativeLabel[nativeLabelOffset] = 0;
4841  }
4842  else
4843  {
4844  nativeLabel = null;
4845  }
4846 
4847  float vMin = 0.0f;
4848  float vMax = 0.0f;
4849  byte* nativeFormat;
4850  int formatByteCount = 0;
4851  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4852  if (formatByteCount > Util.StackAllocationSizeLimit)
4853  {
4854  nativeFormat = Util.Allocate(formatByteCount + 1);
4855  }
4856  else
4857  {
4858  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4859  nativeFormat = nativeFormatStackBytes;
4860  }
4861 
4862  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4863  nativeFormat[nativeFormatOffset] = 0;
4864  ImGuiSliderFlags flags = 0;
4865  fixed (Vector4F* nativeV = &v)
4866  {
4867  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4868  if (labelByteCount > Util.StackAllocationSizeLimit)
4869  {
4870  Util.Free(nativeLabel);
4871  }
4872 
4873  if (formatByteCount > Util.StackAllocationSizeLimit)
4874  {
4875  Util.Free(nativeFormat);
4876  }
4877 
4878  return ret != 0;
4879  }
4880  }
4881 
4890  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin)
4891  {
4892  byte* nativeLabel;
4893  int labelByteCount = 0;
4894  if (label != null)
4895  {
4896  labelByteCount = Encoding.UTF8.GetByteCount(label);
4897  if (labelByteCount > Util.StackAllocationSizeLimit)
4898  {
4899  nativeLabel = Util.Allocate(labelByteCount + 1);
4900  }
4901  else
4902  {
4903  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4904  nativeLabel = nativeLabelStackBytes;
4905  }
4906 
4907  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4908  nativeLabel[nativeLabelOffset] = 0;
4909  }
4910  else
4911  {
4912  nativeLabel = null;
4913  }
4914 
4915  float vMax = 0.0f;
4916  byte* nativeFormat;
4917  int formatByteCount = 0;
4918  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4919  if (formatByteCount > Util.StackAllocationSizeLimit)
4920  {
4921  nativeFormat = Util.Allocate(formatByteCount + 1);
4922  }
4923  else
4924  {
4925  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4926  nativeFormat = nativeFormatStackBytes;
4927  }
4928 
4929  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4930  nativeFormat[nativeFormatOffset] = 0;
4931  ImGuiSliderFlags flags = 0;
4932  fixed (Vector4F* nativeV = &v)
4933  {
4934  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
4935  if (labelByteCount > Util.StackAllocationSizeLimit)
4936  {
4937  Util.Free(nativeLabel);
4938  }
4939 
4940  if (formatByteCount > Util.StackAllocationSizeLimit)
4941  {
4942  Util.Free(nativeFormat);
4943  }
4944 
4945  return ret != 0;
4946  }
4947  }
4948 
4958  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax)
4959  {
4960  byte* nativeLabel;
4961  int labelByteCount = 0;
4962  if (label != null)
4963  {
4964  labelByteCount = Encoding.UTF8.GetByteCount(label);
4965  if (labelByteCount > Util.StackAllocationSizeLimit)
4966  {
4967  nativeLabel = Util.Allocate(labelByteCount + 1);
4968  }
4969  else
4970  {
4971  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4972  nativeLabel = nativeLabelStackBytes;
4973  }
4974 
4975  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4976  nativeLabel[nativeLabelOffset] = 0;
4977  }
4978  else
4979  {
4980  nativeLabel = null;
4981  }
4982 
4983  byte* nativeFormat;
4984  int formatByteCount = 0;
4985  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4986  if (formatByteCount > Util.StackAllocationSizeLimit)
4987  {
4988  nativeFormat = Util.Allocate(formatByteCount + 1);
4989  }
4990  else
4991  {
4992  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4993  nativeFormat = nativeFormatStackBytes;
4994  }
4995 
4996  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4997  nativeFormat[nativeFormatOffset] = 0;
4998  ImGuiSliderFlags flags = 0;
4999  fixed (Vector4F* nativeV = &v)
5000  {
5001  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5002  if (labelByteCount > Util.StackAllocationSizeLimit)
5003  {
5004  Util.Free(nativeLabel);
5005  }
5006 
5007  if (formatByteCount > Util.StackAllocationSizeLimit)
5008  {
5009  Util.Free(nativeFormat);
5010  }
5011 
5012  return ret != 0;
5013  }
5014  }
5015 
5026  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax, string format)
5027  {
5028  byte* nativeLabel;
5029  int labelByteCount = 0;
5030  if (label != null)
5031  {
5032  labelByteCount = Encoding.UTF8.GetByteCount(label);
5033  if (labelByteCount > Util.StackAllocationSizeLimit)
5034  {
5035  nativeLabel = Util.Allocate(labelByteCount + 1);
5036  }
5037  else
5038  {
5039  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5040  nativeLabel = nativeLabelStackBytes;
5041  }
5042 
5043  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5044  nativeLabel[nativeLabelOffset] = 0;
5045  }
5046  else
5047  {
5048  nativeLabel = null;
5049  }
5050 
5051  byte* nativeFormat;
5052  int formatByteCount = 0;
5053  if (format != null)
5054  {
5055  formatByteCount = Encoding.UTF8.GetByteCount(format);
5056  if (formatByteCount > Util.StackAllocationSizeLimit)
5057  {
5058  nativeFormat = Util.Allocate(formatByteCount + 1);
5059  }
5060  else
5061  {
5062  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5063  nativeFormat = nativeFormatStackBytes;
5064  }
5065 
5066  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5067  nativeFormat[nativeFormatOffset] = 0;
5068  }
5069  else
5070  {
5071  nativeFormat = null;
5072  }
5073 
5074  ImGuiSliderFlags flags = 0;
5075  fixed (Vector4F* nativeV = &v)
5076  {
5077  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5078  if (labelByteCount > Util.StackAllocationSizeLimit)
5079  {
5080  Util.Free(nativeLabel);
5081  }
5082 
5083  if (formatByteCount > Util.StackAllocationSizeLimit)
5084  {
5085  Util.Free(nativeFormat);
5086  }
5087 
5088  return ret != 0;
5089  }
5090  }
5091 
5103  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliderFlags flags)
5104  {
5105  byte* nativeLabel;
5106  int labelByteCount = 0;
5107  if (label != null)
5108  {
5109  labelByteCount = Encoding.UTF8.GetByteCount(label);
5110  if (labelByteCount > Util.StackAllocationSizeLimit)
5111  {
5112  nativeLabel = Util.Allocate(labelByteCount + 1);
5113  }
5114  else
5115  {
5116  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5117  nativeLabel = nativeLabelStackBytes;
5118  }
5119 
5120  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5121  nativeLabel[nativeLabelOffset] = 0;
5122  }
5123  else
5124  {
5125  nativeLabel = null;
5126  }
5127 
5128  byte* nativeFormat;
5129  int formatByteCount = 0;
5130  if (format != null)
5131  {
5132  formatByteCount = Encoding.UTF8.GetByteCount(format);
5133  if (formatByteCount > Util.StackAllocationSizeLimit)
5134  {
5135  nativeFormat = Util.Allocate(formatByteCount + 1);
5136  }
5137  else
5138  {
5139  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5140  nativeFormat = nativeFormatStackBytes;
5141  }
5142 
5143  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5144  nativeFormat[nativeFormatOffset] = 0;
5145  }
5146  else
5147  {
5148  nativeFormat = null;
5149  }
5150 
5151  fixed (Vector4F* nativeV = &v)
5152  {
5153  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5154  if (labelByteCount > Util.StackAllocationSizeLimit)
5155  {
5156  Util.Free(nativeLabel);
5157  }
5158 
5159  if (formatByteCount > Util.StackAllocationSizeLimit)
5160  {
5161  Util.Free(nativeFormat);
5162  }
5163 
5164  return ret != 0;
5165  }
5166  }
5167 
5175  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax)
5176  {
5177  byte* nativeLabel;
5178  int labelByteCount = 0;
5179  if (label != null)
5180  {
5181  labelByteCount = Encoding.UTF8.GetByteCount(label);
5182  if (labelByteCount > Util.StackAllocationSizeLimit)
5183  {
5184  nativeLabel = Util.Allocate(labelByteCount + 1);
5185  }
5186  else
5187  {
5188  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5189  nativeLabel = nativeLabelStackBytes;
5190  }
5191 
5192  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5193  nativeLabel[nativeLabelOffset] = 0;
5194  }
5195  else
5196  {
5197  nativeLabel = null;
5198  }
5199 
5200  float vSpeed = 1.0f;
5201  float vMin = 0.0f;
5202  float vMax = 0.0f;
5203  byte* nativeFormat;
5204  int formatByteCount = 0;
5205  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
5206  if (formatByteCount > Util.StackAllocationSizeLimit)
5207  {
5208  nativeFormat = Util.Allocate(formatByteCount + 1);
5209  }
5210  else
5211  {
5212  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5213  nativeFormat = nativeFormatStackBytes;
5214  }
5215 
5216  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
5217  nativeFormat[nativeFormatOffset] = 0;
5218  byte* nativeFormatMax = null;
5219  ImGuiSliderFlags flags = 0;
5220  fixed (float* nativeVCurrentMin = &vCurrentMin)
5221  {
5222  fixed (float* nativeVCurrentMax = &vCurrentMax)
5223  {
5224  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5225  if (labelByteCount > Util.StackAllocationSizeLimit)
5226  {
5227  Util.Free(nativeLabel);
5228  }
5229 
5230  if (formatByteCount > Util.StackAllocationSizeLimit)
5231  {
5232  Util.Free(nativeFormat);
5233  }
5234 
5235  return ret != 0;
5236  }
5237  }
5238  }
5239 
5248  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed)
5249  {
5250  byte* nativeLabel;
5251  int labelByteCount = 0;
5252  if (label != null)
5253  {
5254  labelByteCount = Encoding.UTF8.GetByteCount(label);
5255  if (labelByteCount > Util.StackAllocationSizeLimit)
5256  {
5257  nativeLabel = Util.Allocate(labelByteCount + 1);
5258  }
5259  else
5260  {
5261  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5262  nativeLabel = nativeLabelStackBytes;
5263  }
5264 
5265  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5266  nativeLabel[nativeLabelOffset] = 0;
5267  }
5268  else
5269  {
5270  nativeLabel = null;
5271  }
5272 
5273  float vMin = 0.0f;
5274  float vMax = 0.0f;
5275  byte* nativeFormat;
5276  int formatByteCount = 0;
5277  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
5278  if (formatByteCount > Util.StackAllocationSizeLimit)
5279  {
5280  nativeFormat = Util.Allocate(formatByteCount + 1);
5281  }
5282  else
5283  {
5284  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5285  nativeFormat = nativeFormatStackBytes;
5286  }
5287 
5288  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
5289  nativeFormat[nativeFormatOffset] = 0;
5290  byte* nativeFormatMax = null;
5291  ImGuiSliderFlags flags = 0;
5292  fixed (float* nativeVCurrentMin = &vCurrentMin)
5293  {
5294  fixed (float* nativeVCurrentMax = &vCurrentMax)
5295  {
5296  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5297  if (labelByteCount > Util.StackAllocationSizeLimit)
5298  {
5299  Util.Free(nativeLabel);
5300  }
5301 
5302  if (formatByteCount > Util.StackAllocationSizeLimit)
5303  {
5304  Util.Free(nativeFormat);
5305  }
5306 
5307  return ret != 0;
5308  }
5309  }
5310  }
5311 
5321  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin)
5322  {
5323  byte* nativeLabel;
5324  int labelByteCount = 0;
5325  if (label != null)
5326  {
5327  labelByteCount = Encoding.UTF8.GetByteCount(label);
5328  if (labelByteCount > Util.StackAllocationSizeLimit)
5329  {
5330  nativeLabel = Util.Allocate(labelByteCount + 1);
5331  }
5332  else
5333  {
5334  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5335  nativeLabel = nativeLabelStackBytes;
5336  }
5337 
5338  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5339  nativeLabel[nativeLabelOffset] = 0;
5340  }
5341  else
5342  {
5343  nativeLabel = null;
5344  }
5345 
5346  float vMax = 0.0f;
5347  byte* nativeFormat;
5348  int formatByteCount = 0;
5349  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
5350  if (formatByteCount > Util.StackAllocationSizeLimit)
5351  {
5352  nativeFormat = Util.Allocate(formatByteCount + 1);
5353  }
5354  else
5355  {
5356  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5357  nativeFormat = nativeFormatStackBytes;
5358  }
5359 
5360  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
5361  nativeFormat[nativeFormatOffset] = 0;
5362  byte* nativeFormatMax = null;
5363  ImGuiSliderFlags flags = 0;
5364  fixed (float* nativeVCurrentMin = &vCurrentMin)
5365  {
5366  fixed (float* nativeVCurrentMax = &vCurrentMax)
5367  {
5368  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5369  if (labelByteCount > Util.StackAllocationSizeLimit)
5370  {
5371  Util.Free(nativeLabel);
5372  }
5373 
5374  if (formatByteCount > Util.StackAllocationSizeLimit)
5375  {
5376  Util.Free(nativeFormat);
5377  }
5378 
5379  return ret != 0;
5380  }
5381  }
5382  }
5383 
5394  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax)
5395  {
5396  byte* nativeLabel;
5397  int labelByteCount = 0;
5398  if (label != null)
5399  {
5400  labelByteCount = Encoding.UTF8.GetByteCount(label);
5401  if (labelByteCount > Util.StackAllocationSizeLimit)
5402  {
5403  nativeLabel = Util.Allocate(labelByteCount + 1);
5404  }
5405  else
5406  {
5407  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5408  nativeLabel = nativeLabelStackBytes;
5409  }
5410 
5411  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5412  nativeLabel[nativeLabelOffset] = 0;
5413  }
5414  else
5415  {
5416  nativeLabel = null;
5417  }
5418 
5419  byte* nativeFormat;
5420  int formatByteCount = 0;
5421  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
5422  if (formatByteCount > Util.StackAllocationSizeLimit)
5423  {
5424  nativeFormat = Util.Allocate(formatByteCount + 1);
5425  }
5426  else
5427  {
5428  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5429  nativeFormat = nativeFormatStackBytes;
5430  }
5431 
5432  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
5433  nativeFormat[nativeFormatOffset] = 0;
5434  byte* nativeFormatMax = null;
5435  ImGuiSliderFlags flags = 0;
5436  fixed (float* nativeVCurrentMin = &vCurrentMin)
5437  {
5438  fixed (float* nativeVCurrentMax = &vCurrentMax)
5439  {
5440  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5441  if (labelByteCount > Util.StackAllocationSizeLimit)
5442  {
5443  Util.Free(nativeLabel);
5444  }
5445 
5446  if (formatByteCount > Util.StackAllocationSizeLimit)
5447  {
5448  Util.Free(nativeFormat);
5449  }
5450 
5451  return ret != 0;
5452  }
5453  }
5454  }
5455 
5467  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format)
5468  {
5469  byte* nativeLabel;
5470  int labelByteCount = 0;
5471  if (label != null)
5472  {
5473  labelByteCount = Encoding.UTF8.GetByteCount(label);
5474  if (labelByteCount > Util.StackAllocationSizeLimit)
5475  {
5476  nativeLabel = Util.Allocate(labelByteCount + 1);
5477  }
5478  else
5479  {
5480  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5481  nativeLabel = nativeLabelStackBytes;
5482  }
5483 
5484  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5485  nativeLabel[nativeLabelOffset] = 0;
5486  }
5487  else
5488  {
5489  nativeLabel = null;
5490  }
5491 
5492  byte* nativeFormat;
5493  int formatByteCount = 0;
5494  if (format != null)
5495  {
5496  formatByteCount = Encoding.UTF8.GetByteCount(format);
5497  if (formatByteCount > Util.StackAllocationSizeLimit)
5498  {
5499  nativeFormat = Util.Allocate(formatByteCount + 1);
5500  }
5501  else
5502  {
5503  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5504  nativeFormat = nativeFormatStackBytes;
5505  }
5506 
5507  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5508  nativeFormat[nativeFormatOffset] = 0;
5509  }
5510  else
5511  {
5512  nativeFormat = null;
5513  }
5514 
5515  byte* nativeFormatMax = null;
5516  ImGuiSliderFlags flags = 0;
5517  fixed (float* nativeVCurrentMin = &vCurrentMin)
5518  {
5519  fixed (float* nativeVCurrentMax = &vCurrentMax)
5520  {
5521  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5522  if (labelByteCount > Util.StackAllocationSizeLimit)
5523  {
5524  Util.Free(nativeLabel);
5525  }
5526 
5527  if (formatByteCount > Util.StackAllocationSizeLimit)
5528  {
5529  Util.Free(nativeFormat);
5530  }
5531 
5532  return ret != 0;
5533  }
5534  }
5535  }
5536 
5549  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format, string formatMax)
5550  {
5551  byte* nativeLabel;
5552  int labelByteCount = 0;
5553  if (label != null)
5554  {
5555  labelByteCount = Encoding.UTF8.GetByteCount(label);
5556  if (labelByteCount > Util.StackAllocationSizeLimit)
5557  {
5558  nativeLabel = Util.Allocate(labelByteCount + 1);
5559  }
5560  else
5561  {
5562  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5563  nativeLabel = nativeLabelStackBytes;
5564  }
5565 
5566  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5567  nativeLabel[nativeLabelOffset] = 0;
5568  }
5569  else
5570  {
5571  nativeLabel = null;
5572  }
5573 
5574  byte* nativeFormat;
5575  int formatByteCount = 0;
5576  if (format != null)
5577  {
5578  formatByteCount = Encoding.UTF8.GetByteCount(format);
5579  if (formatByteCount > Util.StackAllocationSizeLimit)
5580  {
5581  nativeFormat = Util.Allocate(formatByteCount + 1);
5582  }
5583  else
5584  {
5585  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5586  nativeFormat = nativeFormatStackBytes;
5587  }
5588 
5589  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5590  nativeFormat[nativeFormatOffset] = 0;
5591  }
5592  else
5593  {
5594  nativeFormat = null;
5595  }
5596 
5597  byte* nativeFormatMax;
5598  int formatMaxByteCount = 0;
5599  if (formatMax != null)
5600  {
5601  formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
5602  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
5603  {
5604  nativeFormatMax = Util.Allocate(formatMaxByteCount + 1);
5605  }
5606  else
5607  {
5608  byte* nativeFormatMaxStackBytes = stackalloc byte[formatMaxByteCount + 1];
5609  nativeFormatMax = nativeFormatMaxStackBytes;
5610  }
5611 
5612  int nativeFormatMaxOffset = Util.GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
5613  nativeFormatMax[nativeFormatMaxOffset] = 0;
5614  }
5615  else
5616  {
5617  nativeFormatMax = null;
5618  }
5619 
5620  ImGuiSliderFlags flags = 0;
5621  fixed (float* nativeVCurrentMin = &vCurrentMin)
5622  {
5623  fixed (float* nativeVCurrentMax = &vCurrentMax)
5624  {
5625  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5626  if (labelByteCount > Util.StackAllocationSizeLimit)
5627  {
5628  Util.Free(nativeLabel);
5629  }
5630 
5631  if (formatByteCount > Util.StackAllocationSizeLimit)
5632  {
5633  Util.Free(nativeFormat);
5634  }
5635 
5636  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
5637  {
5638  Util.Free(nativeFormatMax);
5639  }
5640 
5641  return ret != 0;
5642  }
5643  }
5644  }
5645 
5659  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format, string formatMax, ImGuiSliderFlags flags)
5660  {
5661  byte* nativeLabel;
5662  int labelByteCount = 0;
5663  if (label != null)
5664  {
5665  labelByteCount = Encoding.UTF8.GetByteCount(label);
5666  if (labelByteCount > Util.StackAllocationSizeLimit)
5667  {
5668  nativeLabel = Util.Allocate(labelByteCount + 1);
5669  }
5670  else
5671  {
5672  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5673  nativeLabel = nativeLabelStackBytes;
5674  }
5675 
5676  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5677  nativeLabel[nativeLabelOffset] = 0;
5678  }
5679  else
5680  {
5681  nativeLabel = null;
5682  }
5683 
5684  byte* nativeFormat;
5685  int formatByteCount = 0;
5686  if (format != null)
5687  {
5688  formatByteCount = Encoding.UTF8.GetByteCount(format);
5689  if (formatByteCount > Util.StackAllocationSizeLimit)
5690  {
5691  nativeFormat = Util.Allocate(formatByteCount + 1);
5692  }
5693  else
5694  {
5695  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5696  nativeFormat = nativeFormatStackBytes;
5697  }
5698 
5699  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5700  nativeFormat[nativeFormatOffset] = 0;
5701  }
5702  else
5703  {
5704  nativeFormat = null;
5705  }
5706 
5707  byte* nativeFormatMax;
5708  int formatMaxByteCount = 0;
5709  if (formatMax != null)
5710  {
5711  formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
5712  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
5713  {
5714  nativeFormatMax = Util.Allocate(formatMaxByteCount + 1);
5715  }
5716  else
5717  {
5718  byte* nativeFormatMaxStackBytes = stackalloc byte[formatMaxByteCount + 1];
5719  nativeFormatMax = nativeFormatMaxStackBytes;
5720  }
5721 
5722  int nativeFormatMaxOffset = Util.GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
5723  nativeFormatMax[nativeFormatMaxOffset] = 0;
5724  }
5725  else
5726  {
5727  nativeFormatMax = null;
5728  }
5729 
5730  fixed (float* nativeVCurrentMin = &vCurrentMin)
5731  {
5732  fixed (float* nativeVCurrentMax = &vCurrentMax)
5733  {
5734  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
5735  if (labelByteCount > Util.StackAllocationSizeLimit)
5736  {
5737  Util.Free(nativeLabel);
5738  }
5739 
5740  if (formatByteCount > Util.StackAllocationSizeLimit)
5741  {
5742  Util.Free(nativeFormat);
5743  }
5744 
5745  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
5746  {
5747  Util.Free(nativeFormatMax);
5748  }
5749 
5750  return ret != 0;
5751  }
5752  }
5753  }
5754 
5761  public static bool DragInt(string label, ref int v)
5762  {
5763  byte* nativeLabel;
5764  int labelByteCount = 0;
5765  if (label != null)
5766  {
5767  labelByteCount = Encoding.UTF8.GetByteCount(label);
5768  if (labelByteCount > Util.StackAllocationSizeLimit)
5769  {
5770  nativeLabel = Util.Allocate(labelByteCount + 1);
5771  }
5772  else
5773  {
5774  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5775  nativeLabel = nativeLabelStackBytes;
5776  }
5777 
5778  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5779  nativeLabel[nativeLabelOffset] = 0;
5780  }
5781  else
5782  {
5783  nativeLabel = null;
5784  }
5785 
5786  float vSpeed = 1.0f;
5787  int vMin = 0;
5788  int vMax = 0;
5789  byte* nativeFormat;
5790  int formatByteCount = 0;
5791  formatByteCount = Encoding.UTF8.GetByteCount("%d");
5792  if (formatByteCount > Util.StackAllocationSizeLimit)
5793  {
5794  nativeFormat = Util.Allocate(formatByteCount + 1);
5795  }
5796  else
5797  {
5798  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5799  nativeFormat = nativeFormatStackBytes;
5800  }
5801 
5802  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
5803  nativeFormat[nativeFormatOffset] = 0;
5804  ImGuiSliderFlags flags = 0;
5805  fixed (int* nativeV = &v)
5806  {
5807  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5808  if (labelByteCount > Util.StackAllocationSizeLimit)
5809  {
5810  Util.Free(nativeLabel);
5811  }
5812 
5813  if (formatByteCount > Util.StackAllocationSizeLimit)
5814  {
5815  Util.Free(nativeFormat);
5816  }
5817 
5818  return ret != 0;
5819  }
5820  }
5821 
5829  public static bool DragInt(string label, ref int v, float vSpeed)
5830  {
5831  byte* nativeLabel;
5832  int labelByteCount = 0;
5833  if (label != null)
5834  {
5835  labelByteCount = Encoding.UTF8.GetByteCount(label);
5836  if (labelByteCount > Util.StackAllocationSizeLimit)
5837  {
5838  nativeLabel = Util.Allocate(labelByteCount + 1);
5839  }
5840  else
5841  {
5842  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5843  nativeLabel = nativeLabelStackBytes;
5844  }
5845 
5846  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5847  nativeLabel[nativeLabelOffset] = 0;
5848  }
5849  else
5850  {
5851  nativeLabel = null;
5852  }
5853 
5854  int vMin = 0;
5855  int vMax = 0;
5856  byte* nativeFormat;
5857  int formatByteCount = 0;
5858  formatByteCount = Encoding.UTF8.GetByteCount("%d");
5859  if (formatByteCount > Util.StackAllocationSizeLimit)
5860  {
5861  nativeFormat = Util.Allocate(formatByteCount + 1);
5862  }
5863  else
5864  {
5865  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5866  nativeFormat = nativeFormatStackBytes;
5867  }
5868 
5869  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
5870  nativeFormat[nativeFormatOffset] = 0;
5871  ImGuiSliderFlags flags = 0;
5872  fixed (int* nativeV = &v)
5873  {
5874  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5875  if (labelByteCount > Util.StackAllocationSizeLimit)
5876  {
5877  Util.Free(nativeLabel);
5878  }
5879 
5880  if (formatByteCount > Util.StackAllocationSizeLimit)
5881  {
5882  Util.Free(nativeFormat);
5883  }
5884 
5885  return ret != 0;
5886  }
5887  }
5888 
5897  public static bool DragInt(string label, ref int v, float vSpeed, int vMin)
5898  {
5899  byte* nativeLabel;
5900  int labelByteCount = 0;
5901  if (label != null)
5902  {
5903  labelByteCount = Encoding.UTF8.GetByteCount(label);
5904  if (labelByteCount > Util.StackAllocationSizeLimit)
5905  {
5906  nativeLabel = Util.Allocate(labelByteCount + 1);
5907  }
5908  else
5909  {
5910  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5911  nativeLabel = nativeLabelStackBytes;
5912  }
5913 
5914  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5915  nativeLabel[nativeLabelOffset] = 0;
5916  }
5917  else
5918  {
5919  nativeLabel = null;
5920  }
5921 
5922  int vMax = 0;
5923  byte* nativeFormat;
5924  int formatByteCount = 0;
5925  formatByteCount = Encoding.UTF8.GetByteCount("%d");
5926  if (formatByteCount > Util.StackAllocationSizeLimit)
5927  {
5928  nativeFormat = Util.Allocate(formatByteCount + 1);
5929  }
5930  else
5931  {
5932  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5933  nativeFormat = nativeFormatStackBytes;
5934  }
5935 
5936  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
5937  nativeFormat[nativeFormatOffset] = 0;
5938  ImGuiSliderFlags flags = 0;
5939  fixed (int* nativeV = &v)
5940  {
5941  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
5942  if (labelByteCount > Util.StackAllocationSizeLimit)
5943  {
5944  Util.Free(nativeLabel);
5945  }
5946 
5947  if (formatByteCount > Util.StackAllocationSizeLimit)
5948  {
5949  Util.Free(nativeFormat);
5950  }
5951 
5952  return ret != 0;
5953  }
5954  }
5955 
5965  public static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax)
5966  {
5967  byte* nativeLabel;
5968  int labelByteCount = 0;
5969  if (label != null)
5970  {
5971  labelByteCount = Encoding.UTF8.GetByteCount(label);
5972  if (labelByteCount > Util.StackAllocationSizeLimit)
5973  {
5974  nativeLabel = Util.Allocate(labelByteCount + 1);
5975  }
5976  else
5977  {
5978  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5979  nativeLabel = nativeLabelStackBytes;
5980  }
5981 
5982  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5983  nativeLabel[nativeLabelOffset] = 0;
5984  }
5985  else
5986  {
5987  nativeLabel = null;
5988  }
5989 
5990  byte* nativeFormat;
5991  int formatByteCount = 0;
5992  formatByteCount = Encoding.UTF8.GetByteCount("%d");
5993  if (formatByteCount > Util.StackAllocationSizeLimit)
5994  {
5995  nativeFormat = Util.Allocate(formatByteCount + 1);
5996  }
5997  else
5998  {
5999  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6000  nativeFormat = nativeFormatStackBytes;
6001  }
6002 
6003  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6004  nativeFormat[nativeFormatOffset] = 0;
6005  ImGuiSliderFlags flags = 0;
6006  fixed (int* nativeV = &v)
6007  {
6008  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6009  if (labelByteCount > Util.StackAllocationSizeLimit)
6010  {
6011  Util.Free(nativeLabel);
6012  }
6013 
6014  if (formatByteCount > Util.StackAllocationSizeLimit)
6015  {
6016  Util.Free(nativeFormat);
6017  }
6018 
6019  return ret != 0;
6020  }
6021  }
6022 
6033  public static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
6034  {
6035  byte* nativeLabel;
6036  int labelByteCount = 0;
6037  if (label != null)
6038  {
6039  labelByteCount = Encoding.UTF8.GetByteCount(label);
6040  if (labelByteCount > Util.StackAllocationSizeLimit)
6041  {
6042  nativeLabel = Util.Allocate(labelByteCount + 1);
6043  }
6044  else
6045  {
6046  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6047  nativeLabel = nativeLabelStackBytes;
6048  }
6049 
6050  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6051  nativeLabel[nativeLabelOffset] = 0;
6052  }
6053  else
6054  {
6055  nativeLabel = null;
6056  }
6057 
6058  byte* nativeFormat;
6059  int formatByteCount = 0;
6060  if (format != null)
6061  {
6062  formatByteCount = Encoding.UTF8.GetByteCount(format);
6063  if (formatByteCount > Util.StackAllocationSizeLimit)
6064  {
6065  nativeFormat = Util.Allocate(formatByteCount + 1);
6066  }
6067  else
6068  {
6069  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6070  nativeFormat = nativeFormatStackBytes;
6071  }
6072 
6073  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6074  nativeFormat[nativeFormatOffset] = 0;
6075  }
6076  else
6077  {
6078  nativeFormat = null;
6079  }
6080 
6081  ImGuiSliderFlags flags = 0;
6082  fixed (int* nativeV = &v)
6083  {
6084  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6085  if (labelByteCount > Util.StackAllocationSizeLimit)
6086  {
6087  Util.Free(nativeLabel);
6088  }
6089 
6090  if (formatByteCount > Util.StackAllocationSizeLimit)
6091  {
6092  Util.Free(nativeFormat);
6093  }
6094 
6095  return ret != 0;
6096  }
6097  }
6098 
6110  public static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliderFlags flags)
6111  {
6112  byte* nativeLabel;
6113  int labelByteCount = 0;
6114  if (label != null)
6115  {
6116  labelByteCount = Encoding.UTF8.GetByteCount(label);
6117  if (labelByteCount > Util.StackAllocationSizeLimit)
6118  {
6119  nativeLabel = Util.Allocate(labelByteCount + 1);
6120  }
6121  else
6122  {
6123  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6124  nativeLabel = nativeLabelStackBytes;
6125  }
6126 
6127  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6128  nativeLabel[nativeLabelOffset] = 0;
6129  }
6130  else
6131  {
6132  nativeLabel = null;
6133  }
6134 
6135  byte* nativeFormat;
6136  int formatByteCount = 0;
6137  if (format != null)
6138  {
6139  formatByteCount = Encoding.UTF8.GetByteCount(format);
6140  if (formatByteCount > Util.StackAllocationSizeLimit)
6141  {
6142  nativeFormat = Util.Allocate(formatByteCount + 1);
6143  }
6144  else
6145  {
6146  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6147  nativeFormat = nativeFormatStackBytes;
6148  }
6149 
6150  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6151  nativeFormat[nativeFormatOffset] = 0;
6152  }
6153  else
6154  {
6155  nativeFormat = null;
6156  }
6157 
6158  fixed (int* nativeV = &v)
6159  {
6160  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6161  if (labelByteCount > Util.StackAllocationSizeLimit)
6162  {
6163  Util.Free(nativeLabel);
6164  }
6165 
6166  if (formatByteCount > Util.StackAllocationSizeLimit)
6167  {
6168  Util.Free(nativeFormat);
6169  }
6170 
6171  return ret != 0;
6172  }
6173  }
6174 
6181  public static bool DragInt2(string label, ref int v)
6182  {
6183  byte* nativeLabel;
6184  int labelByteCount = 0;
6185  if (label != null)
6186  {
6187  labelByteCount = Encoding.UTF8.GetByteCount(label);
6188  if (labelByteCount > Util.StackAllocationSizeLimit)
6189  {
6190  nativeLabel = Util.Allocate(labelByteCount + 1);
6191  }
6192  else
6193  {
6194  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6195  nativeLabel = nativeLabelStackBytes;
6196  }
6197 
6198  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6199  nativeLabel[nativeLabelOffset] = 0;
6200  }
6201  else
6202  {
6203  nativeLabel = null;
6204  }
6205 
6206  float vSpeed = 1.0f;
6207  int vMin = 0;
6208  int vMax = 0;
6209  byte* nativeFormat;
6210  int formatByteCount = 0;
6211  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6212  if (formatByteCount > Util.StackAllocationSizeLimit)
6213  {
6214  nativeFormat = Util.Allocate(formatByteCount + 1);
6215  }
6216  else
6217  {
6218  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6219  nativeFormat = nativeFormatStackBytes;
6220  }
6221 
6222  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6223  nativeFormat[nativeFormatOffset] = 0;
6224  ImGuiSliderFlags flags = 0;
6225  fixed (int* nativeV = &v)
6226  {
6227  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6228  if (labelByteCount > Util.StackAllocationSizeLimit)
6229  {
6230  Util.Free(nativeLabel);
6231  }
6232 
6233  if (formatByteCount > Util.StackAllocationSizeLimit)
6234  {
6235  Util.Free(nativeFormat);
6236  }
6237 
6238  return ret != 0;
6239  }
6240  }
6241 
6249  public static bool DragInt2(string label, ref int v, float vSpeed)
6250  {
6251  byte* nativeLabel;
6252  int labelByteCount = 0;
6253  if (label != null)
6254  {
6255  labelByteCount = Encoding.UTF8.GetByteCount(label);
6256  if (labelByteCount > Util.StackAllocationSizeLimit)
6257  {
6258  nativeLabel = Util.Allocate(labelByteCount + 1);
6259  }
6260  else
6261  {
6262  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6263  nativeLabel = nativeLabelStackBytes;
6264  }
6265 
6266  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6267  nativeLabel[nativeLabelOffset] = 0;
6268  }
6269  else
6270  {
6271  nativeLabel = null;
6272  }
6273 
6274  int vMin = 0;
6275  int vMax = 0;
6276  byte* nativeFormat;
6277  int formatByteCount = 0;
6278  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6279  if (formatByteCount > Util.StackAllocationSizeLimit)
6280  {
6281  nativeFormat = Util.Allocate(formatByteCount + 1);
6282  }
6283  else
6284  {
6285  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6286  nativeFormat = nativeFormatStackBytes;
6287  }
6288 
6289  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6290  nativeFormat[nativeFormatOffset] = 0;
6291  ImGuiSliderFlags flags = 0;
6292  fixed (int* nativeV = &v)
6293  {
6294  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6295  if (labelByteCount > Util.StackAllocationSizeLimit)
6296  {
6297  Util.Free(nativeLabel);
6298  }
6299 
6300  if (formatByteCount > Util.StackAllocationSizeLimit)
6301  {
6302  Util.Free(nativeFormat);
6303  }
6304 
6305  return ret != 0;
6306  }
6307  }
6308 
6317  public static bool DragInt2(string label, ref int v, float vSpeed, int vMin)
6318  {
6319  byte* nativeLabel;
6320  int labelByteCount = 0;
6321  if (label != null)
6322  {
6323  labelByteCount = Encoding.UTF8.GetByteCount(label);
6324  if (labelByteCount > Util.StackAllocationSizeLimit)
6325  {
6326  nativeLabel = Util.Allocate(labelByteCount + 1);
6327  }
6328  else
6329  {
6330  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6331  nativeLabel = nativeLabelStackBytes;
6332  }
6333 
6334  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6335  nativeLabel[nativeLabelOffset] = 0;
6336  }
6337  else
6338  {
6339  nativeLabel = null;
6340  }
6341 
6342  int vMax = 0;
6343  byte* nativeFormat;
6344  int formatByteCount = 0;
6345  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6346  if (formatByteCount > Util.StackAllocationSizeLimit)
6347  {
6348  nativeFormat = Util.Allocate(formatByteCount + 1);
6349  }
6350  else
6351  {
6352  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6353  nativeFormat = nativeFormatStackBytes;
6354  }
6355 
6356  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6357  nativeFormat[nativeFormatOffset] = 0;
6358  ImGuiSliderFlags flags = 0;
6359  fixed (int* nativeV = &v)
6360  {
6361  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6362  if (labelByteCount > Util.StackAllocationSizeLimit)
6363  {
6364  Util.Free(nativeLabel);
6365  }
6366 
6367  if (formatByteCount > Util.StackAllocationSizeLimit)
6368  {
6369  Util.Free(nativeFormat);
6370  }
6371 
6372  return ret != 0;
6373  }
6374  }
6375 
6385  public static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax)
6386  {
6387  byte* nativeLabel;
6388  int labelByteCount = 0;
6389  if (label != null)
6390  {
6391  labelByteCount = Encoding.UTF8.GetByteCount(label);
6392  if (labelByteCount > Util.StackAllocationSizeLimit)
6393  {
6394  nativeLabel = Util.Allocate(labelByteCount + 1);
6395  }
6396  else
6397  {
6398  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6399  nativeLabel = nativeLabelStackBytes;
6400  }
6401 
6402  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6403  nativeLabel[nativeLabelOffset] = 0;
6404  }
6405  else
6406  {
6407  nativeLabel = null;
6408  }
6409 
6410  byte* nativeFormat;
6411  int formatByteCount = 0;
6412  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6413  if (formatByteCount > Util.StackAllocationSizeLimit)
6414  {
6415  nativeFormat = Util.Allocate(formatByteCount + 1);
6416  }
6417  else
6418  {
6419  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6420  nativeFormat = nativeFormatStackBytes;
6421  }
6422 
6423  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6424  nativeFormat[nativeFormatOffset] = 0;
6425  ImGuiSliderFlags flags = 0;
6426  fixed (int* nativeV = &v)
6427  {
6428  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6429  if (labelByteCount > Util.StackAllocationSizeLimit)
6430  {
6431  Util.Free(nativeLabel);
6432  }
6433 
6434  if (formatByteCount > Util.StackAllocationSizeLimit)
6435  {
6436  Util.Free(nativeFormat);
6437  }
6438 
6439  return ret != 0;
6440  }
6441  }
6442 
6453  public static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
6454  {
6455  byte* nativeLabel;
6456  int labelByteCount = 0;
6457  if (label != null)
6458  {
6459  labelByteCount = Encoding.UTF8.GetByteCount(label);
6460  if (labelByteCount > Util.StackAllocationSizeLimit)
6461  {
6462  nativeLabel = Util.Allocate(labelByteCount + 1);
6463  }
6464  else
6465  {
6466  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6467  nativeLabel = nativeLabelStackBytes;
6468  }
6469 
6470  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6471  nativeLabel[nativeLabelOffset] = 0;
6472  }
6473  else
6474  {
6475  nativeLabel = null;
6476  }
6477 
6478  byte* nativeFormat;
6479  int formatByteCount = 0;
6480  if (format != null)
6481  {
6482  formatByteCount = Encoding.UTF8.GetByteCount(format);
6483  if (formatByteCount > Util.StackAllocationSizeLimit)
6484  {
6485  nativeFormat = Util.Allocate(formatByteCount + 1);
6486  }
6487  else
6488  {
6489  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6490  nativeFormat = nativeFormatStackBytes;
6491  }
6492 
6493  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6494  nativeFormat[nativeFormatOffset] = 0;
6495  }
6496  else
6497  {
6498  nativeFormat = null;
6499  }
6500 
6501  ImGuiSliderFlags flags = 0;
6502  fixed (int* nativeV = &v)
6503  {
6504  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6505  if (labelByteCount > Util.StackAllocationSizeLimit)
6506  {
6507  Util.Free(nativeLabel);
6508  }
6509 
6510  if (formatByteCount > Util.StackAllocationSizeLimit)
6511  {
6512  Util.Free(nativeFormat);
6513  }
6514 
6515  return ret != 0;
6516  }
6517  }
6518 
6530  public static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliderFlags flags)
6531  {
6532  byte* nativeLabel;
6533  int labelByteCount = 0;
6534  if (label != null)
6535  {
6536  labelByteCount = Encoding.UTF8.GetByteCount(label);
6537  if (labelByteCount > Util.StackAllocationSizeLimit)
6538  {
6539  nativeLabel = Util.Allocate(labelByteCount + 1);
6540  }
6541  else
6542  {
6543  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6544  nativeLabel = nativeLabelStackBytes;
6545  }
6546 
6547  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6548  nativeLabel[nativeLabelOffset] = 0;
6549  }
6550  else
6551  {
6552  nativeLabel = null;
6553  }
6554 
6555  byte* nativeFormat;
6556  int formatByteCount = 0;
6557  if (format != null)
6558  {
6559  formatByteCount = Encoding.UTF8.GetByteCount(format);
6560  if (formatByteCount > Util.StackAllocationSizeLimit)
6561  {
6562  nativeFormat = Util.Allocate(formatByteCount + 1);
6563  }
6564  else
6565  {
6566  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6567  nativeFormat = nativeFormatStackBytes;
6568  }
6569 
6570  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6571  nativeFormat[nativeFormatOffset] = 0;
6572  }
6573  else
6574  {
6575  nativeFormat = null;
6576  }
6577 
6578  fixed (int* nativeV = &v)
6579  {
6580  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6581  if (labelByteCount > Util.StackAllocationSizeLimit)
6582  {
6583  Util.Free(nativeLabel);
6584  }
6585 
6586  if (formatByteCount > Util.StackAllocationSizeLimit)
6587  {
6588  Util.Free(nativeFormat);
6589  }
6590 
6591  return ret != 0;
6592  }
6593  }
6594 
6601  public static bool DragInt3(string label, ref int v)
6602  {
6603  byte* nativeLabel;
6604  int labelByteCount = 0;
6605  if (label != null)
6606  {
6607  labelByteCount = Encoding.UTF8.GetByteCount(label);
6608  if (labelByteCount > Util.StackAllocationSizeLimit)
6609  {
6610  nativeLabel = Util.Allocate(labelByteCount + 1);
6611  }
6612  else
6613  {
6614  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6615  nativeLabel = nativeLabelStackBytes;
6616  }
6617 
6618  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6619  nativeLabel[nativeLabelOffset] = 0;
6620  }
6621  else
6622  {
6623  nativeLabel = null;
6624  }
6625 
6626  float vSpeed = 1.0f;
6627  int vMin = 0;
6628  int vMax = 0;
6629  byte* nativeFormat;
6630  int formatByteCount = 0;
6631  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6632  if (formatByteCount > Util.StackAllocationSizeLimit)
6633  {
6634  nativeFormat = Util.Allocate(formatByteCount + 1);
6635  }
6636  else
6637  {
6638  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6639  nativeFormat = nativeFormatStackBytes;
6640  }
6641 
6642  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6643  nativeFormat[nativeFormatOffset] = 0;
6644  ImGuiSliderFlags flags = 0;
6645  fixed (int* nativeV = &v)
6646  {
6647  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6648  if (labelByteCount > Util.StackAllocationSizeLimit)
6649  {
6650  Util.Free(nativeLabel);
6651  }
6652 
6653  if (formatByteCount > Util.StackAllocationSizeLimit)
6654  {
6655  Util.Free(nativeFormat);
6656  }
6657 
6658  return ret != 0;
6659  }
6660  }
6661 
6669  public static bool DragInt3(string label, ref int v, float vSpeed)
6670  {
6671  byte* nativeLabel;
6672  int labelByteCount = 0;
6673  if (label != null)
6674  {
6675  labelByteCount = Encoding.UTF8.GetByteCount(label);
6676  if (labelByteCount > Util.StackAllocationSizeLimit)
6677  {
6678  nativeLabel = Util.Allocate(labelByteCount + 1);
6679  }
6680  else
6681  {
6682  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6683  nativeLabel = nativeLabelStackBytes;
6684  }
6685 
6686  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6687  nativeLabel[nativeLabelOffset] = 0;
6688  }
6689  else
6690  {
6691  nativeLabel = null;
6692  }
6693 
6694  int vMin = 0;
6695  int vMax = 0;
6696  byte* nativeFormat;
6697  int formatByteCount = 0;
6698  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6699  if (formatByteCount > Util.StackAllocationSizeLimit)
6700  {
6701  nativeFormat = Util.Allocate(formatByteCount + 1);
6702  }
6703  else
6704  {
6705  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6706  nativeFormat = nativeFormatStackBytes;
6707  }
6708 
6709  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6710  nativeFormat[nativeFormatOffset] = 0;
6711  ImGuiSliderFlags flags = 0;
6712  fixed (int* nativeV = &v)
6713  {
6714  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6715  if (labelByteCount > Util.StackAllocationSizeLimit)
6716  {
6717  Util.Free(nativeLabel);
6718  }
6719 
6720  if (formatByteCount > Util.StackAllocationSizeLimit)
6721  {
6722  Util.Free(nativeFormat);
6723  }
6724 
6725  return ret != 0;
6726  }
6727  }
6728 
6737  public static bool DragInt3(string label, ref int v, float vSpeed, int vMin)
6738  {
6739  byte* nativeLabel;
6740  int labelByteCount = 0;
6741  if (label != null)
6742  {
6743  labelByteCount = Encoding.UTF8.GetByteCount(label);
6744  if (labelByteCount > Util.StackAllocationSizeLimit)
6745  {
6746  nativeLabel = Util.Allocate(labelByteCount + 1);
6747  }
6748  else
6749  {
6750  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6751  nativeLabel = nativeLabelStackBytes;
6752  }
6753 
6754  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6755  nativeLabel[nativeLabelOffset] = 0;
6756  }
6757  else
6758  {
6759  nativeLabel = null;
6760  }
6761 
6762  int vMax = 0;
6763  byte* nativeFormat;
6764  int formatByteCount = 0;
6765  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6766  if (formatByteCount > Util.StackAllocationSizeLimit)
6767  {
6768  nativeFormat = Util.Allocate(formatByteCount + 1);
6769  }
6770  else
6771  {
6772  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6773  nativeFormat = nativeFormatStackBytes;
6774  }
6775 
6776  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6777  nativeFormat[nativeFormatOffset] = 0;
6778  ImGuiSliderFlags flags = 0;
6779  fixed (int* nativeV = &v)
6780  {
6781  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6782  if (labelByteCount > Util.StackAllocationSizeLimit)
6783  {
6784  Util.Free(nativeLabel);
6785  }
6786 
6787  if (formatByteCount > Util.StackAllocationSizeLimit)
6788  {
6789  Util.Free(nativeFormat);
6790  }
6791 
6792  return ret != 0;
6793  }
6794  }
6795 
6805  public static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax)
6806  {
6807  byte* nativeLabel;
6808  int labelByteCount = 0;
6809  if (label != null)
6810  {
6811  labelByteCount = Encoding.UTF8.GetByteCount(label);
6812  if (labelByteCount > Util.StackAllocationSizeLimit)
6813  {
6814  nativeLabel = Util.Allocate(labelByteCount + 1);
6815  }
6816  else
6817  {
6818  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6819  nativeLabel = nativeLabelStackBytes;
6820  }
6821 
6822  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6823  nativeLabel[nativeLabelOffset] = 0;
6824  }
6825  else
6826  {
6827  nativeLabel = null;
6828  }
6829 
6830  byte* nativeFormat;
6831  int formatByteCount = 0;
6832  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6833  if (formatByteCount > Util.StackAllocationSizeLimit)
6834  {
6835  nativeFormat = Util.Allocate(formatByteCount + 1);
6836  }
6837  else
6838  {
6839  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6840  nativeFormat = nativeFormatStackBytes;
6841  }
6842 
6843  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6844  nativeFormat[nativeFormatOffset] = 0;
6845  ImGuiSliderFlags flags = 0;
6846  fixed (int* nativeV = &v)
6847  {
6848  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6849  if (labelByteCount > Util.StackAllocationSizeLimit)
6850  {
6851  Util.Free(nativeLabel);
6852  }
6853 
6854  if (formatByteCount > Util.StackAllocationSizeLimit)
6855  {
6856  Util.Free(nativeFormat);
6857  }
6858 
6859  return ret != 0;
6860  }
6861  }
6862 
6873  public static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
6874  {
6875  byte* nativeLabel;
6876  int labelByteCount = 0;
6877  if (label != null)
6878  {
6879  labelByteCount = Encoding.UTF8.GetByteCount(label);
6880  if (labelByteCount > Util.StackAllocationSizeLimit)
6881  {
6882  nativeLabel = Util.Allocate(labelByteCount + 1);
6883  }
6884  else
6885  {
6886  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6887  nativeLabel = nativeLabelStackBytes;
6888  }
6889 
6890  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6891  nativeLabel[nativeLabelOffset] = 0;
6892  }
6893  else
6894  {
6895  nativeLabel = null;
6896  }
6897 
6898  byte* nativeFormat;
6899  int formatByteCount = 0;
6900  if (format != null)
6901  {
6902  formatByteCount = Encoding.UTF8.GetByteCount(format);
6903  if (formatByteCount > Util.StackAllocationSizeLimit)
6904  {
6905  nativeFormat = Util.Allocate(formatByteCount + 1);
6906  }
6907  else
6908  {
6909  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6910  nativeFormat = nativeFormatStackBytes;
6911  }
6912 
6913  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6914  nativeFormat[nativeFormatOffset] = 0;
6915  }
6916  else
6917  {
6918  nativeFormat = null;
6919  }
6920 
6921  ImGuiSliderFlags flags = 0;
6922  fixed (int* nativeV = &v)
6923  {
6924  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
6925  if (labelByteCount > Util.StackAllocationSizeLimit)
6926  {
6927  Util.Free(nativeLabel);
6928  }
6929 
6930  if (formatByteCount > Util.StackAllocationSizeLimit)
6931  {
6932  Util.Free(nativeFormat);
6933  }
6934 
6935  return ret != 0;
6936  }
6937  }
6938 
6950  public static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliderFlags flags)
6951  {
6952  byte* nativeLabel;
6953  int labelByteCount = 0;
6954  if (label != null)
6955  {
6956  labelByteCount = Encoding.UTF8.GetByteCount(label);
6957  if (labelByteCount > Util.StackAllocationSizeLimit)
6958  {
6959  nativeLabel = Util.Allocate(labelByteCount + 1);
6960  }
6961  else
6962  {
6963  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6964  nativeLabel = nativeLabelStackBytes;
6965  }
6966 
6967  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6968  nativeLabel[nativeLabelOffset] = 0;
6969  }
6970  else
6971  {
6972  nativeLabel = null;
6973  }
6974 
6975  byte* nativeFormat;
6976  int formatByteCount = 0;
6977  if (format != null)
6978  {
6979  formatByteCount = Encoding.UTF8.GetByteCount(format);
6980  if (formatByteCount > Util.StackAllocationSizeLimit)
6981  {
6982  nativeFormat = Util.Allocate(formatByteCount + 1);
6983  }
6984  else
6985  {
6986  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6987  nativeFormat = nativeFormatStackBytes;
6988  }
6989 
6990  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6991  nativeFormat[nativeFormatOffset] = 0;
6992  }
6993  else
6994  {
6995  nativeFormat = null;
6996  }
6997 
6998  fixed (int* nativeV = &v)
6999  {
7000  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
7001  if (labelByteCount > Util.StackAllocationSizeLimit)
7002  {
7003  Util.Free(nativeLabel);
7004  }
7005 
7006  if (formatByteCount > Util.StackAllocationSizeLimit)
7007  {
7008  Util.Free(nativeFormat);
7009  }
7010 
7011  return ret != 0;
7012  }
7013  }
7014 
7021  public static bool DragInt4(string label, ref int v)
7022  {
7023  byte* nativeLabel;
7024  int labelByteCount = 0;
7025  if (label != null)
7026  {
7027  labelByteCount = Encoding.UTF8.GetByteCount(label);
7028  if (labelByteCount > Util.StackAllocationSizeLimit)
7029  {
7030  nativeLabel = Util.Allocate(labelByteCount + 1);
7031  }
7032  else
7033  {
7034  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7035  nativeLabel = nativeLabelStackBytes;
7036  }
7037 
7038  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7039  nativeLabel[nativeLabelOffset] = 0;
7040  }
7041  else
7042  {
7043  nativeLabel = null;
7044  }
7045 
7046  float vSpeed = 1.0f;
7047  int vMin = 0;
7048  int vMax = 0;
7049  byte* nativeFormat;
7050  int formatByteCount = 0;
7051  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7052  if (formatByteCount > Util.StackAllocationSizeLimit)
7053  {
7054  nativeFormat = Util.Allocate(formatByteCount + 1);
7055  }
7056  else
7057  {
7058  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7059  nativeFormat = nativeFormatStackBytes;
7060  }
7061 
7062  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7063  nativeFormat[nativeFormatOffset] = 0;
7064  ImGuiSliderFlags flags = 0;
7065  fixed (int* nativeV = &v)
7066  {
7067  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
7068  if (labelByteCount > Util.StackAllocationSizeLimit)
7069  {
7070  Util.Free(nativeLabel);
7071  }
7072 
7073  if (formatByteCount > Util.StackAllocationSizeLimit)
7074  {
7075  Util.Free(nativeFormat);
7076  }
7077 
7078  return ret != 0;
7079  }
7080  }
7081 
7089  public static bool DragInt4(string label, ref int v, float vSpeed)
7090  {
7091  byte* nativeLabel;
7092  int labelByteCount = 0;
7093  if (label != null)
7094  {
7095  labelByteCount = Encoding.UTF8.GetByteCount(label);
7096  if (labelByteCount > Util.StackAllocationSizeLimit)
7097  {
7098  nativeLabel = Util.Allocate(labelByteCount + 1);
7099  }
7100  else
7101  {
7102  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7103  nativeLabel = nativeLabelStackBytes;
7104  }
7105 
7106  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7107  nativeLabel[nativeLabelOffset] = 0;
7108  }
7109  else
7110  {
7111  nativeLabel = null;
7112  }
7113 
7114  int vMin = 0;
7115  int vMax = 0;
7116  byte* nativeFormat;
7117  int formatByteCount = 0;
7118  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7119  if (formatByteCount > Util.StackAllocationSizeLimit)
7120  {
7121  nativeFormat = Util.Allocate(formatByteCount + 1);
7122  }
7123  else
7124  {
7125  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7126  nativeFormat = nativeFormatStackBytes;
7127  }
7128 
7129  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7130  nativeFormat[nativeFormatOffset] = 0;
7131  ImGuiSliderFlags flags = 0;
7132  fixed (int* nativeV = &v)
7133  {
7134  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
7135  if (labelByteCount > Util.StackAllocationSizeLimit)
7136  {
7137  Util.Free(nativeLabel);
7138  }
7139 
7140  if (formatByteCount > Util.StackAllocationSizeLimit)
7141  {
7142  Util.Free(nativeFormat);
7143  }
7144 
7145  return ret != 0;
7146  }
7147  }
7148 
7157  public static bool DragInt4(string label, ref int v, float vSpeed, int vMin)
7158  {
7159  byte* nativeLabel;
7160  int labelByteCount = 0;
7161  if (label != null)
7162  {
7163  labelByteCount = Encoding.UTF8.GetByteCount(label);
7164  if (labelByteCount > Util.StackAllocationSizeLimit)
7165  {
7166  nativeLabel = Util.Allocate(labelByteCount + 1);
7167  }
7168  else
7169  {
7170  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7171  nativeLabel = nativeLabelStackBytes;
7172  }
7173 
7174  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7175  nativeLabel[nativeLabelOffset] = 0;
7176  }
7177  else
7178  {
7179  nativeLabel = null;
7180  }
7181 
7182  int vMax = 0;
7183  byte* nativeFormat;
7184  int formatByteCount = 0;
7185  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7186  if (formatByteCount > Util.StackAllocationSizeLimit)
7187  {
7188  nativeFormat = Util.Allocate(formatByteCount + 1);
7189  }
7190  else
7191  {
7192  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7193  nativeFormat = nativeFormatStackBytes;
7194  }
7195 
7196  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7197  nativeFormat[nativeFormatOffset] = 0;
7198  ImGuiSliderFlags flags = 0;
7199  fixed (int* nativeV = &v)
7200  {
7201  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
7202  if (labelByteCount > Util.StackAllocationSizeLimit)
7203  {
7204  Util.Free(nativeLabel);
7205  }
7206 
7207  if (formatByteCount > Util.StackAllocationSizeLimit)
7208  {
7209  Util.Free(nativeFormat);
7210  }
7211 
7212  return ret != 0;
7213  }
7214  }
7215 
7225  public static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax)
7226  {
7227  byte* nativeLabel;
7228  int labelByteCount = 0;
7229  if (label != null)
7230  {
7231  labelByteCount = Encoding.UTF8.GetByteCount(label);
7232  if (labelByteCount > Util.StackAllocationSizeLimit)
7233  {
7234  nativeLabel = Util.Allocate(labelByteCount + 1);
7235  }
7236  else
7237  {
7238  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7239  nativeLabel = nativeLabelStackBytes;
7240  }
7241 
7242  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7243  nativeLabel[nativeLabelOffset] = 0;
7244  }
7245  else
7246  {
7247  nativeLabel = null;
7248  }
7249 
7250  byte* nativeFormat;
7251  int formatByteCount = 0;
7252  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7253  if (formatByteCount > Util.StackAllocationSizeLimit)
7254  {
7255  nativeFormat = Util.Allocate(formatByteCount + 1);
7256  }
7257  else
7258  {
7259  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7260  nativeFormat = nativeFormatStackBytes;
7261  }
7262 
7263  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7264  nativeFormat[nativeFormatOffset] = 0;
7265  ImGuiSliderFlags flags = 0;
7266  fixed (int* nativeV = &v)
7267  {
7268  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
7269  if (labelByteCount > Util.StackAllocationSizeLimit)
7270  {
7271  Util.Free(nativeLabel);
7272  }
7273 
7274  if (formatByteCount > Util.StackAllocationSizeLimit)
7275  {
7276  Util.Free(nativeFormat);
7277  }
7278 
7279  return ret != 0;
7280  }
7281  }
7282 
7293  public static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
7294  {
7295  byte* nativeLabel;
7296  int labelByteCount = 0;
7297  if (label != null)
7298  {
7299  labelByteCount = Encoding.UTF8.GetByteCount(label);
7300  if (labelByteCount > Util.StackAllocationSizeLimit)
7301  {
7302  nativeLabel = Util.Allocate(labelByteCount + 1);
7303  }
7304  else
7305  {
7306  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7307  nativeLabel = nativeLabelStackBytes;
7308  }
7309 
7310  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7311  nativeLabel[nativeLabelOffset] = 0;
7312  }
7313  else
7314  {
7315  nativeLabel = null;
7316  }
7317 
7318  byte* nativeFormat;
7319  int formatByteCount = 0;
7320  if (format != null)
7321  {
7322  formatByteCount = Encoding.UTF8.GetByteCount(format);
7323  if (formatByteCount > Util.StackAllocationSizeLimit)
7324  {
7325  nativeFormat = Util.Allocate(formatByteCount + 1);
7326  }
7327  else
7328  {
7329  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7330  nativeFormat = nativeFormatStackBytes;
7331  }
7332 
7333  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7334  nativeFormat[nativeFormatOffset] = 0;
7335  }
7336  else
7337  {
7338  nativeFormat = null;
7339  }
7340 
7341  ImGuiSliderFlags flags = 0;
7342  fixed (int* nativeV = &v)
7343  {
7344  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
7345  if (labelByteCount > Util.StackAllocationSizeLimit)
7346  {
7347  Util.Free(nativeLabel);
7348  }
7349 
7350  if (formatByteCount > Util.StackAllocationSizeLimit)
7351  {
7352  Util.Free(nativeFormat);
7353  }
7354 
7355  return ret != 0;
7356  }
7357  }
7358 
7370  public static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliderFlags flags)
7371  {
7372  byte* nativeLabel;
7373  int labelByteCount = 0;
7374  if (label != null)
7375  {
7376  labelByteCount = Encoding.UTF8.GetByteCount(label);
7377  if (labelByteCount > Util.StackAllocationSizeLimit)
7378  {
7379  nativeLabel = Util.Allocate(labelByteCount + 1);
7380  }
7381  else
7382  {
7383  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7384  nativeLabel = nativeLabelStackBytes;
7385  }
7386 
7387  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7388  nativeLabel[nativeLabelOffset] = 0;
7389  }
7390  else
7391  {
7392  nativeLabel = null;
7393  }
7394 
7395  byte* nativeFormat;
7396  int formatByteCount = 0;
7397  if (format != null)
7398  {
7399  formatByteCount = Encoding.UTF8.GetByteCount(format);
7400  if (formatByteCount > Util.StackAllocationSizeLimit)
7401  {
7402  nativeFormat = Util.Allocate(formatByteCount + 1);
7403  }
7404  else
7405  {
7406  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7407  nativeFormat = nativeFormatStackBytes;
7408  }
7409 
7410  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7411  nativeFormat[nativeFormatOffset] = 0;
7412  }
7413  else
7414  {
7415  nativeFormat = null;
7416  }
7417 
7418  fixed (int* nativeV = &v)
7419  {
7420  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flags);
7421  if (labelByteCount > Util.StackAllocationSizeLimit)
7422  {
7423  Util.Free(nativeLabel);
7424  }
7425 
7426  if (formatByteCount > Util.StackAllocationSizeLimit)
7427  {
7428  Util.Free(nativeFormat);
7429  }
7430 
7431  return ret != 0;
7432  }
7433  }
7434 
7442  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax)
7443  {
7444  byte* nativeLabel;
7445  int labelByteCount = 0;
7446  if (label != null)
7447  {
7448  labelByteCount = Encoding.UTF8.GetByteCount(label);
7449  if (labelByteCount > Util.StackAllocationSizeLimit)
7450  {
7451  nativeLabel = Util.Allocate(labelByteCount + 1);
7452  }
7453  else
7454  {
7455  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7456  nativeLabel = nativeLabelStackBytes;
7457  }
7458 
7459  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7460  nativeLabel[nativeLabelOffset] = 0;
7461  }
7462  else
7463  {
7464  nativeLabel = null;
7465  }
7466 
7467  float vSpeed = 1.0f;
7468  int vMin = 0;
7469  int vMax = 0;
7470  byte* nativeFormat;
7471  int formatByteCount = 0;
7472  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7473  if (formatByteCount > Util.StackAllocationSizeLimit)
7474  {
7475  nativeFormat = Util.Allocate(formatByteCount + 1);
7476  }
7477  else
7478  {
7479  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7480  nativeFormat = nativeFormatStackBytes;
7481  }
7482 
7483  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7484  nativeFormat[nativeFormatOffset] = 0;
7485  byte* nativeFormatMax = null;
7486  ImGuiSliderFlags flags = 0;
7487  fixed (int* nativeVCurrentMin = &vCurrentMin)
7488  {
7489  fixed (int* nativeVCurrentMax = &vCurrentMax)
7490  {
7491  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7492  if (labelByteCount > Util.StackAllocationSizeLimit)
7493  {
7494  Util.Free(nativeLabel);
7495  }
7496 
7497  if (formatByteCount > Util.StackAllocationSizeLimit)
7498  {
7499  Util.Free(nativeFormat);
7500  }
7501 
7502  return ret != 0;
7503  }
7504  }
7505  }
7506 
7515  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed)
7516  {
7517  byte* nativeLabel;
7518  int labelByteCount = 0;
7519  if (label != null)
7520  {
7521  labelByteCount = Encoding.UTF8.GetByteCount(label);
7522  if (labelByteCount > Util.StackAllocationSizeLimit)
7523  {
7524  nativeLabel = Util.Allocate(labelByteCount + 1);
7525  }
7526  else
7527  {
7528  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7529  nativeLabel = nativeLabelStackBytes;
7530  }
7531 
7532  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7533  nativeLabel[nativeLabelOffset] = 0;
7534  }
7535  else
7536  {
7537  nativeLabel = null;
7538  }
7539 
7540  int vMin = 0;
7541  int vMax = 0;
7542  byte* nativeFormat;
7543  int formatByteCount = 0;
7544  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7545  if (formatByteCount > Util.StackAllocationSizeLimit)
7546  {
7547  nativeFormat = Util.Allocate(formatByteCount + 1);
7548  }
7549  else
7550  {
7551  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7552  nativeFormat = nativeFormatStackBytes;
7553  }
7554 
7555  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7556  nativeFormat[nativeFormatOffset] = 0;
7557  byte* nativeFormatMax = null;
7558  ImGuiSliderFlags flags = 0;
7559  fixed (int* nativeVCurrentMin = &vCurrentMin)
7560  {
7561  fixed (int* nativeVCurrentMax = &vCurrentMax)
7562  {
7563  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7564  if (labelByteCount > Util.StackAllocationSizeLimit)
7565  {
7566  Util.Free(nativeLabel);
7567  }
7568 
7569  if (formatByteCount > Util.StackAllocationSizeLimit)
7570  {
7571  Util.Free(nativeFormat);
7572  }
7573 
7574  return ret != 0;
7575  }
7576  }
7577  }
7578 
7588  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin)
7589  {
7590  byte* nativeLabel;
7591  int labelByteCount = 0;
7592  if (label != null)
7593  {
7594  labelByteCount = Encoding.UTF8.GetByteCount(label);
7595  if (labelByteCount > Util.StackAllocationSizeLimit)
7596  {
7597  nativeLabel = Util.Allocate(labelByteCount + 1);
7598  }
7599  else
7600  {
7601  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7602  nativeLabel = nativeLabelStackBytes;
7603  }
7604 
7605  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7606  nativeLabel[nativeLabelOffset] = 0;
7607  }
7608  else
7609  {
7610  nativeLabel = null;
7611  }
7612 
7613  int vMax = 0;
7614  byte* nativeFormat;
7615  int formatByteCount = 0;
7616  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7617  if (formatByteCount > Util.StackAllocationSizeLimit)
7618  {
7619  nativeFormat = Util.Allocate(formatByteCount + 1);
7620  }
7621  else
7622  {
7623  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7624  nativeFormat = nativeFormatStackBytes;
7625  }
7626 
7627  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7628  nativeFormat[nativeFormatOffset] = 0;
7629  byte* nativeFormatMax = null;
7630  ImGuiSliderFlags flags = 0;
7631  fixed (int* nativeVCurrentMin = &vCurrentMin)
7632  {
7633  fixed (int* nativeVCurrentMax = &vCurrentMax)
7634  {
7635  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7636  if (labelByteCount > Util.StackAllocationSizeLimit)
7637  {
7638  Util.Free(nativeLabel);
7639  }
7640 
7641  if (formatByteCount > Util.StackAllocationSizeLimit)
7642  {
7643  Util.Free(nativeFormat);
7644  }
7645 
7646  return ret != 0;
7647  }
7648  }
7649  }
7650 
7661  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax)
7662  {
7663  byte* nativeLabel;
7664  int labelByteCount = 0;
7665  if (label != null)
7666  {
7667  labelByteCount = Encoding.UTF8.GetByteCount(label);
7668  if (labelByteCount > Util.StackAllocationSizeLimit)
7669  {
7670  nativeLabel = Util.Allocate(labelByteCount + 1);
7671  }
7672  else
7673  {
7674  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7675  nativeLabel = nativeLabelStackBytes;
7676  }
7677 
7678  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7679  nativeLabel[nativeLabelOffset] = 0;
7680  }
7681  else
7682  {
7683  nativeLabel = null;
7684  }
7685 
7686  byte* nativeFormat;
7687  int formatByteCount = 0;
7688  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7689  if (formatByteCount > Util.StackAllocationSizeLimit)
7690  {
7691  nativeFormat = Util.Allocate(formatByteCount + 1);
7692  }
7693  else
7694  {
7695  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7696  nativeFormat = nativeFormatStackBytes;
7697  }
7698 
7699  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7700  nativeFormat[nativeFormatOffset] = 0;
7701  byte* nativeFormatMax = null;
7702  ImGuiSliderFlags flags = 0;
7703  fixed (int* nativeVCurrentMin = &vCurrentMin)
7704  {
7705  fixed (int* nativeVCurrentMax = &vCurrentMax)
7706  {
7707  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7708  if (labelByteCount > Util.StackAllocationSizeLimit)
7709  {
7710  Util.Free(nativeLabel);
7711  }
7712 
7713  if (formatByteCount > Util.StackAllocationSizeLimit)
7714  {
7715  Util.Free(nativeFormat);
7716  }
7717 
7718  return ret != 0;
7719  }
7720  }
7721  }
7722 
7734  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format)
7735  {
7736  byte* nativeLabel;
7737  int labelByteCount = 0;
7738  if (label != null)
7739  {
7740  labelByteCount = Encoding.UTF8.GetByteCount(label);
7741  if (labelByteCount > Util.StackAllocationSizeLimit)
7742  {
7743  nativeLabel = Util.Allocate(labelByteCount + 1);
7744  }
7745  else
7746  {
7747  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7748  nativeLabel = nativeLabelStackBytes;
7749  }
7750 
7751  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7752  nativeLabel[nativeLabelOffset] = 0;
7753  }
7754  else
7755  {
7756  nativeLabel = null;
7757  }
7758 
7759  byte* nativeFormat;
7760  int formatByteCount = 0;
7761  if (format != null)
7762  {
7763  formatByteCount = Encoding.UTF8.GetByteCount(format);
7764  if (formatByteCount > Util.StackAllocationSizeLimit)
7765  {
7766  nativeFormat = Util.Allocate(formatByteCount + 1);
7767  }
7768  else
7769  {
7770  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7771  nativeFormat = nativeFormatStackBytes;
7772  }
7773 
7774  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7775  nativeFormat[nativeFormatOffset] = 0;
7776  }
7777  else
7778  {
7779  nativeFormat = null;
7780  }
7781 
7782  byte* nativeFormatMax = null;
7783  ImGuiSliderFlags flags = 0;
7784  fixed (int* nativeVCurrentMin = &vCurrentMin)
7785  {
7786  fixed (int* nativeVCurrentMax = &vCurrentMax)
7787  {
7788  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7789  if (labelByteCount > Util.StackAllocationSizeLimit)
7790  {
7791  Util.Free(nativeLabel);
7792  }
7793 
7794  if (formatByteCount > Util.StackAllocationSizeLimit)
7795  {
7796  Util.Free(nativeFormat);
7797  }
7798 
7799  return ret != 0;
7800  }
7801  }
7802  }
7803 
7816  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format, string formatMax)
7817  {
7818  byte* nativeLabel;
7819  int labelByteCount = 0;
7820  if (label != null)
7821  {
7822  labelByteCount = Encoding.UTF8.GetByteCount(label);
7823  if (labelByteCount > Util.StackAllocationSizeLimit)
7824  {
7825  nativeLabel = Util.Allocate(labelByteCount + 1);
7826  }
7827  else
7828  {
7829  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7830  nativeLabel = nativeLabelStackBytes;
7831  }
7832 
7833  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7834  nativeLabel[nativeLabelOffset] = 0;
7835  }
7836  else
7837  {
7838  nativeLabel = null;
7839  }
7840 
7841  byte* nativeFormat;
7842  int formatByteCount = 0;
7843  if (format != null)
7844  {
7845  formatByteCount = Encoding.UTF8.GetByteCount(format);
7846  if (formatByteCount > Util.StackAllocationSizeLimit)
7847  {
7848  nativeFormat = Util.Allocate(formatByteCount + 1);
7849  }
7850  else
7851  {
7852  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7853  nativeFormat = nativeFormatStackBytes;
7854  }
7855 
7856  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7857  nativeFormat[nativeFormatOffset] = 0;
7858  }
7859  else
7860  {
7861  nativeFormat = null;
7862  }
7863 
7864  byte* nativeFormatMax;
7865  int formatMaxByteCount = 0;
7866  if (formatMax != null)
7867  {
7868  formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
7869  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
7870  {
7871  nativeFormatMax = Util.Allocate(formatMaxByteCount + 1);
7872  }
7873  else
7874  {
7875  byte* nativeFormatMaxStackBytes = stackalloc byte[formatMaxByteCount + 1];
7876  nativeFormatMax = nativeFormatMaxStackBytes;
7877  }
7878 
7879  int nativeFormatMaxOffset = Util.GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
7880  nativeFormatMax[nativeFormatMaxOffset] = 0;
7881  }
7882  else
7883  {
7884  nativeFormatMax = null;
7885  }
7886 
7887  ImGuiSliderFlags flags = 0;
7888  fixed (int* nativeVCurrentMin = &vCurrentMin)
7889  {
7890  fixed (int* nativeVCurrentMax = &vCurrentMax)
7891  {
7892  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
7893  if (labelByteCount > Util.StackAllocationSizeLimit)
7894  {
7895  Util.Free(nativeLabel);
7896  }
7897 
7898  if (formatByteCount > Util.StackAllocationSizeLimit)
7899  {
7900  Util.Free(nativeFormat);
7901  }
7902 
7903  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
7904  {
7905  Util.Free(nativeFormatMax);
7906  }
7907 
7908  return ret != 0;
7909  }
7910  }
7911  }
7912 
7926  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format, string formatMax, ImGuiSliderFlags flags)
7927  {
7928  byte* nativeLabel;
7929  int labelByteCount = 0;
7930  if (label != null)
7931  {
7932  labelByteCount = Encoding.UTF8.GetByteCount(label);
7933  if (labelByteCount > Util.StackAllocationSizeLimit)
7934  {
7935  nativeLabel = Util.Allocate(labelByteCount + 1);
7936  }
7937  else
7938  {
7939  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7940  nativeLabel = nativeLabelStackBytes;
7941  }
7942 
7943  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7944  nativeLabel[nativeLabelOffset] = 0;
7945  }
7946  else
7947  {
7948  nativeLabel = null;
7949  }
7950 
7951  byte* nativeFormat;
7952  int formatByteCount = 0;
7953  if (format != null)
7954  {
7955  formatByteCount = Encoding.UTF8.GetByteCount(format);
7956  if (formatByteCount > Util.StackAllocationSizeLimit)
7957  {
7958  nativeFormat = Util.Allocate(formatByteCount + 1);
7959  }
7960  else
7961  {
7962  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7963  nativeFormat = nativeFormatStackBytes;
7964  }
7965 
7966  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7967  nativeFormat[nativeFormatOffset] = 0;
7968  }
7969  else
7970  {
7971  nativeFormat = null;
7972  }
7973 
7974  byte* nativeFormatMax;
7975  int formatMaxByteCount = 0;
7976  if (formatMax != null)
7977  {
7978  formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
7979  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
7980  {
7981  nativeFormatMax = Util.Allocate(formatMaxByteCount + 1);
7982  }
7983  else
7984  {
7985  byte* nativeFormatMaxStackBytes = stackalloc byte[formatMaxByteCount + 1];
7986  nativeFormatMax = nativeFormatMaxStackBytes;
7987  }
7988 
7989  int nativeFormatMaxOffset = Util.GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
7990  nativeFormatMax[nativeFormatMaxOffset] = 0;
7991  }
7992  else
7993  {
7994  nativeFormatMax = null;
7995  }
7996 
7997  fixed (int* nativeVCurrentMin = &vCurrentMin)
7998  {
7999  fixed (int* nativeVCurrentMax = &vCurrentMax)
8000  {
8001  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flags);
8002  if (labelByteCount > Util.StackAllocationSizeLimit)
8003  {
8004  Util.Free(nativeLabel);
8005  }
8006 
8007  if (formatByteCount > Util.StackAllocationSizeLimit)
8008  {
8009  Util.Free(nativeFormat);
8010  }
8011 
8012  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
8013  {
8014  Util.Free(nativeFormatMax);
8015  }
8016 
8017  return ret != 0;
8018  }
8019  }
8020  }
8021 
8029  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData)
8030  {
8031  byte* nativeLabel;
8032  int labelByteCount = 0;
8033  if (label != null)
8034  {
8035  labelByteCount = Encoding.UTF8.GetByteCount(label);
8036  if (labelByteCount > Util.StackAllocationSizeLimit)
8037  {
8038  nativeLabel = Util.Allocate(labelByteCount + 1);
8039  }
8040  else
8041  {
8042  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8043  nativeLabel = nativeLabelStackBytes;
8044  }
8045 
8046  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8047  nativeLabel[nativeLabelOffset] = 0;
8048  }
8049  else
8050  {
8051  nativeLabel = null;
8052  }
8053 
8054  void* nativePData = pData.ToPointer();
8055  float vSpeed = 1.0f;
8056  void* pMin = null;
8057  void* pMax = null;
8058  byte* nativeFormat = null;
8059  ImGuiSliderFlags flags = 0;
8060  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, pMin, pMax, nativeFormat, flags);
8061  if (labelByteCount > Util.StackAllocationSizeLimit)
8062  {
8063  Util.Free(nativeLabel);
8064  }
8065 
8066  return ret != 0;
8067  }
8068 
8077  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed)
8078  {
8079  byte* nativeLabel;
8080  int labelByteCount = 0;
8081  if (label != null)
8082  {
8083  labelByteCount = Encoding.UTF8.GetByteCount(label);
8084  if (labelByteCount > Util.StackAllocationSizeLimit)
8085  {
8086  nativeLabel = Util.Allocate(labelByteCount + 1);
8087  }
8088  else
8089  {
8090  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8091  nativeLabel = nativeLabelStackBytes;
8092  }
8093 
8094  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8095  nativeLabel[nativeLabelOffset] = 0;
8096  }
8097  else
8098  {
8099  nativeLabel = null;
8100  }
8101 
8102  void* nativePData = pData.ToPointer();
8103  void* pMin = null;
8104  void* pMax = null;
8105  byte* nativeFormat = null;
8106  ImGuiSliderFlags flags = 0;
8107  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, pMin, pMax, nativeFormat, flags);
8108  if (labelByteCount > Util.StackAllocationSizeLimit)
8109  {
8110  Util.Free(nativeLabel);
8111  }
8112 
8113  return ret != 0;
8114  }
8115 
8125  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin)
8126  {
8127  byte* nativeLabel;
8128  int labelByteCount = 0;
8129  if (label != null)
8130  {
8131  labelByteCount = Encoding.UTF8.GetByteCount(label);
8132  if (labelByteCount > Util.StackAllocationSizeLimit)
8133  {
8134  nativeLabel = Util.Allocate(labelByteCount + 1);
8135  }
8136  else
8137  {
8138  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8139  nativeLabel = nativeLabelStackBytes;
8140  }
8141 
8142  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8143  nativeLabel[nativeLabelOffset] = 0;
8144  }
8145  else
8146  {
8147  nativeLabel = null;
8148  }
8149 
8150  void* nativePData = pData.ToPointer();
8151  void* nativePMin = pMin.ToPointer();
8152  void* pMax = null;
8153  byte* nativeFormat = null;
8154  ImGuiSliderFlags flags = 0;
8155  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, pMax, nativeFormat, flags);
8156  if (labelByteCount > Util.StackAllocationSizeLimit)
8157  {
8158  Util.Free(nativeLabel);
8159  }
8160 
8161  return ret != 0;
8162  }
8163 
8174  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax)
8175  {
8176  byte* nativeLabel;
8177  int labelByteCount = 0;
8178  if (label != null)
8179  {
8180  labelByteCount = Encoding.UTF8.GetByteCount(label);
8181  if (labelByteCount > Util.StackAllocationSizeLimit)
8182  {
8183  nativeLabel = Util.Allocate(labelByteCount + 1);
8184  }
8185  else
8186  {
8187  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8188  nativeLabel = nativeLabelStackBytes;
8189  }
8190 
8191  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8192  nativeLabel[nativeLabelOffset] = 0;
8193  }
8194  else
8195  {
8196  nativeLabel = null;
8197  }
8198 
8199  void* nativePData = pData.ToPointer();
8200  void* nativePMin = pMin.ToPointer();
8201  void* nativePMax = pMax.ToPointer();
8202  byte* nativeFormat = null;
8203  ImGuiSliderFlags flags = 0;
8204  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8205  if (labelByteCount > Util.StackAllocationSizeLimit)
8206  {
8207  Util.Free(nativeLabel);
8208  }
8209 
8210  return ret != 0;
8211  }
8212 
8224  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax, string format)
8225  {
8226  byte* nativeLabel;
8227  int labelByteCount = 0;
8228  if (label != null)
8229  {
8230  labelByteCount = Encoding.UTF8.GetByteCount(label);
8231  if (labelByteCount > Util.StackAllocationSizeLimit)
8232  {
8233  nativeLabel = Util.Allocate(labelByteCount + 1);
8234  }
8235  else
8236  {
8237  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8238  nativeLabel = nativeLabelStackBytes;
8239  }
8240 
8241  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8242  nativeLabel[nativeLabelOffset] = 0;
8243  }
8244  else
8245  {
8246  nativeLabel = null;
8247  }
8248 
8249  void* nativePData = pData.ToPointer();
8250  void* nativePMin = pMin.ToPointer();
8251  void* nativePMax = pMax.ToPointer();
8252  byte* nativeFormat;
8253  int formatByteCount = 0;
8254  if (format != null)
8255  {
8256  formatByteCount = Encoding.UTF8.GetByteCount(format);
8257  if (formatByteCount > Util.StackAllocationSizeLimit)
8258  {
8259  nativeFormat = Util.Allocate(formatByteCount + 1);
8260  }
8261  else
8262  {
8263  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
8264  nativeFormat = nativeFormatStackBytes;
8265  }
8266 
8267  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
8268  nativeFormat[nativeFormatOffset] = 0;
8269  }
8270  else
8271  {
8272  nativeFormat = null;
8273  }
8274 
8275  ImGuiSliderFlags flags = 0;
8276  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8277  if (labelByteCount > Util.StackAllocationSizeLimit)
8278  {
8279  Util.Free(nativeLabel);
8280  }
8281 
8282  if (formatByteCount > Util.StackAllocationSizeLimit)
8283  {
8284  Util.Free(nativeFormat);
8285  }
8286 
8287  return ret != 0;
8288  }
8289 
8302  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
8303  {
8304  byte* nativeLabel;
8305  int labelByteCount = 0;
8306  if (label != null)
8307  {
8308  labelByteCount = Encoding.UTF8.GetByteCount(label);
8309  if (labelByteCount > Util.StackAllocationSizeLimit)
8310  {
8311  nativeLabel = Util.Allocate(labelByteCount + 1);
8312  }
8313  else
8314  {
8315  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8316  nativeLabel = nativeLabelStackBytes;
8317  }
8318 
8319  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8320  nativeLabel[nativeLabelOffset] = 0;
8321  }
8322  else
8323  {
8324  nativeLabel = null;
8325  }
8326 
8327  void* nativePData = pData.ToPointer();
8328  void* nativePMin = pMin.ToPointer();
8329  void* nativePMax = pMax.ToPointer();
8330  byte* nativeFormat;
8331  int formatByteCount = 0;
8332  if (format != null)
8333  {
8334  formatByteCount = Encoding.UTF8.GetByteCount(format);
8335  if (formatByteCount > Util.StackAllocationSizeLimit)
8336  {
8337  nativeFormat = Util.Allocate(formatByteCount + 1);
8338  }
8339  else
8340  {
8341  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
8342  nativeFormat = nativeFormatStackBytes;
8343  }
8344 
8345  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
8346  nativeFormat[nativeFormatOffset] = 0;
8347  }
8348  else
8349  {
8350  nativeFormat = null;
8351  }
8352 
8353  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8354  if (labelByteCount > Util.StackAllocationSizeLimit)
8355  {
8356  Util.Free(nativeLabel);
8357  }
8358 
8359  if (formatByteCount > Util.StackAllocationSizeLimit)
8360  {
8361  Util.Free(nativeFormat);
8362  }
8363 
8364  return ret != 0;
8365  }
8366 
8375  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components)
8376  {
8377  byte* nativeLabel;
8378  int labelByteCount = 0;
8379  if (label != null)
8380  {
8381  labelByteCount = Encoding.UTF8.GetByteCount(label);
8382  if (labelByteCount > Util.StackAllocationSizeLimit)
8383  {
8384  nativeLabel = Util.Allocate(labelByteCount + 1);
8385  }
8386  else
8387  {
8388  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8389  nativeLabel = nativeLabelStackBytes;
8390  }
8391 
8392  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8393  nativeLabel[nativeLabelOffset] = 0;
8394  }
8395  else
8396  {
8397  nativeLabel = null;
8398  }
8399 
8400  void* nativePData = pData.ToPointer();
8401  float vSpeed = 1.0f;
8402  void* pMin = null;
8403  void* pMax = null;
8404  byte* nativeFormat = null;
8405  ImGuiSliderFlags flags = 0;
8406  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, pMin, pMax, nativeFormat, flags);
8407  if (labelByteCount > Util.StackAllocationSizeLimit)
8408  {
8409  Util.Free(nativeLabel);
8410  }
8411 
8412  return ret != 0;
8413  }
8414 
8424  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed)
8425  {
8426  byte* nativeLabel;
8427  int labelByteCount = 0;
8428  if (label != null)
8429  {
8430  labelByteCount = Encoding.UTF8.GetByteCount(label);
8431  if (labelByteCount > Util.StackAllocationSizeLimit)
8432  {
8433  nativeLabel = Util.Allocate(labelByteCount + 1);
8434  }
8435  else
8436  {
8437  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8438  nativeLabel = nativeLabelStackBytes;
8439  }
8440 
8441  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8442  nativeLabel[nativeLabelOffset] = 0;
8443  }
8444  else
8445  {
8446  nativeLabel = null;
8447  }
8448 
8449  void* nativePData = pData.ToPointer();
8450  void* pMin = null;
8451  void* pMax = null;
8452  byte* nativeFormat = null;
8453  ImGuiSliderFlags flags = 0;
8454  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, pMin, pMax, nativeFormat, flags);
8455  if (labelByteCount > Util.StackAllocationSizeLimit)
8456  {
8457  Util.Free(nativeLabel);
8458  }
8459 
8460  return ret != 0;
8461  }
8462 
8473  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin)
8474  {
8475  byte* nativeLabel;
8476  int labelByteCount = 0;
8477  if (label != null)
8478  {
8479  labelByteCount = Encoding.UTF8.GetByteCount(label);
8480  if (labelByteCount > Util.StackAllocationSizeLimit)
8481  {
8482  nativeLabel = Util.Allocate(labelByteCount + 1);
8483  }
8484  else
8485  {
8486  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8487  nativeLabel = nativeLabelStackBytes;
8488  }
8489 
8490  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8491  nativeLabel[nativeLabelOffset] = 0;
8492  }
8493  else
8494  {
8495  nativeLabel = null;
8496  }
8497 
8498  void* nativePData = pData.ToPointer();
8499  void* nativePMin = pMin.ToPointer();
8500  void* pMax = null;
8501  byte* nativeFormat = null;
8502  ImGuiSliderFlags flags = 0;
8503  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, pMax, nativeFormat, flags);
8504  if (labelByteCount > Util.StackAllocationSizeLimit)
8505  {
8506  Util.Free(nativeLabel);
8507  }
8508 
8509  return ret != 0;
8510  }
8511 
8523  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax)
8524  {
8525  byte* nativeLabel;
8526  int labelByteCount = 0;
8527  if (label != null)
8528  {
8529  labelByteCount = Encoding.UTF8.GetByteCount(label);
8530  if (labelByteCount > Util.StackAllocationSizeLimit)
8531  {
8532  nativeLabel = Util.Allocate(labelByteCount + 1);
8533  }
8534  else
8535  {
8536  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8537  nativeLabel = nativeLabelStackBytes;
8538  }
8539 
8540  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8541  nativeLabel[nativeLabelOffset] = 0;
8542  }
8543  else
8544  {
8545  nativeLabel = null;
8546  }
8547 
8548  void* nativePData = pData.ToPointer();
8549  void* nativePMin = pMin.ToPointer();
8550  void* nativePMax = pMax.ToPointer();
8551  byte* nativeFormat = null;
8552  ImGuiSliderFlags flags = 0;
8553  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8554  if (labelByteCount > Util.StackAllocationSizeLimit)
8555  {
8556  Util.Free(nativeLabel);
8557  }
8558 
8559  return ret != 0;
8560  }
8561 
8574  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax, string format)
8575  {
8576  byte* nativeLabel;
8577  int labelByteCount = 0;
8578  if (label != null)
8579  {
8580  labelByteCount = Encoding.UTF8.GetByteCount(label);
8581  if (labelByteCount > Util.StackAllocationSizeLimit)
8582  {
8583  nativeLabel = Util.Allocate(labelByteCount + 1);
8584  }
8585  else
8586  {
8587  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8588  nativeLabel = nativeLabelStackBytes;
8589  }
8590 
8591  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8592  nativeLabel[nativeLabelOffset] = 0;
8593  }
8594  else
8595  {
8596  nativeLabel = null;
8597  }
8598 
8599  void* nativePData = pData.ToPointer();
8600  void* nativePMin = pMin.ToPointer();
8601  void* nativePMax = pMax.ToPointer();
8602  byte* nativeFormat;
8603  int formatByteCount = 0;
8604  if (format != null)
8605  {
8606  formatByteCount = Encoding.UTF8.GetByteCount(format);
8607  if (formatByteCount > Util.StackAllocationSizeLimit)
8608  {
8609  nativeFormat = Util.Allocate(formatByteCount + 1);
8610  }
8611  else
8612  {
8613  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
8614  nativeFormat = nativeFormatStackBytes;
8615  }
8616 
8617  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
8618  nativeFormat[nativeFormatOffset] = 0;
8619  }
8620  else
8621  {
8622  nativeFormat = null;
8623  }
8624 
8625  ImGuiSliderFlags flags = 0;
8626  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8627  if (labelByteCount > Util.StackAllocationSizeLimit)
8628  {
8629  Util.Free(nativeLabel);
8630  }
8631 
8632  if (formatByteCount > Util.StackAllocationSizeLimit)
8633  {
8634  Util.Free(nativeFormat);
8635  }
8636 
8637  return ret != 0;
8638  }
8639 
8653  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
8654  {
8655  byte* nativeLabel;
8656  int labelByteCount = 0;
8657  if (label != null)
8658  {
8659  labelByteCount = Encoding.UTF8.GetByteCount(label);
8660  if (labelByteCount > Util.StackAllocationSizeLimit)
8661  {
8662  nativeLabel = Util.Allocate(labelByteCount + 1);
8663  }
8664  else
8665  {
8666  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8667  nativeLabel = nativeLabelStackBytes;
8668  }
8669 
8670  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8671  nativeLabel[nativeLabelOffset] = 0;
8672  }
8673  else
8674  {
8675  nativeLabel = null;
8676  }
8677 
8678  void* nativePData = pData.ToPointer();
8679  void* nativePMin = pMin.ToPointer();
8680  void* nativePMax = pMax.ToPointer();
8681  byte* nativeFormat;
8682  int formatByteCount = 0;
8683  if (format != null)
8684  {
8685  formatByteCount = Encoding.UTF8.GetByteCount(format);
8686  if (formatByteCount > Util.StackAllocationSizeLimit)
8687  {
8688  nativeFormat = Util.Allocate(formatByteCount + 1);
8689  }
8690  else
8691  {
8692  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
8693  nativeFormat = nativeFormatStackBytes;
8694  }
8695 
8696  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
8697  nativeFormat[nativeFormatOffset] = 0;
8698  }
8699  else
8700  {
8701  nativeFormat = null;
8702  }
8703 
8704  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flags);
8705  if (labelByteCount > Util.StackAllocationSizeLimit)
8706  {
8707  Util.Free(nativeLabel);
8708  }
8709 
8710  if (formatByteCount > Util.StackAllocationSizeLimit)
8711  {
8712  Util.Free(nativeFormat);
8713  }
8714 
8715  return ret != 0;
8716  }
8717 
8722  public static void Dummy(Vector2F size)
8723  {
8724  ImGuiNative.igDummy(size);
8725  }
8726 
8730  public static void End()
8731  {
8732  ImGuiNative.igEnd();
8733  }
8734 
8738  public static void EndChild()
8739  {
8740  ImGuiNative.igEndChild();
8741  }
8742 
8746  public static void EndChildFrame()
8747  {
8748  ImGuiNative.igEndChildFrame();
8749  }
8750 
8754  public static void EndCombo()
8755  {
8756  ImGuiNative.igEndCombo();
8757  }
8758 
8762  public static void EndDisabled()
8763  {
8764  ImGuiNative.igEndDisabled();
8765  }
8766 
8770  public static void EndDragDropSource()
8771  {
8772  ImGuiNative.igEndDragDropSource();
8773  }
8774 
8778  public static void EndDragDropTarget()
8779  {
8780  ImGuiNative.igEndDragDropTarget();
8781  }
8782 
8786  public static void EndFrame()
8787  {
8788  ImGuiNative.igEndFrame();
8789  }
8790 
8794  public static void EndGroup()
8795  {
8796  ImGuiNative.igEndGroup();
8797  }
8798 
8802  public static void EndListBox()
8803  {
8804  ImGuiNative.igEndListBox();
8805  }
8806 
8810  public static void EndMainMenuBar()
8811  {
8812  ImGuiNative.igEndMainMenuBar();
8813  }
8814 
8818  public static void EndMenu()
8819  {
8820  ImGuiNative.igEndMenu();
8821  }
8822 
8826  public static void EndMenuBar()
8827  {
8828  ImGuiNative.igEndMenuBar();
8829  }
8830 
8834  public static void EndPopup()
8835  {
8836  ImGuiNative.igEndPopup();
8837  }
8838 
8842  public static void EndTabBar()
8843  {
8844  ImGuiNative.igEndTabBar();
8845  }
8846 
8850  public static void EndTabItem()
8851  {
8852  ImGuiNative.igEndTabItem();
8853  }
8854 
8858  public static void EndTable()
8859  {
8860  ImGuiNative.igEndTable();
8861  }
8862 
8866  public static void EndTooltip()
8867  {
8868  ImGuiNative.igEndTooltip();
8869  }
8870 
8876  public static ImGuiViewportPtr FindViewportById(uint id)
8877  {
8878  ImGuiViewport* ret = ImGuiNative.igFindViewportByID(id);
8879  return new ImGuiViewportPtr(ret);
8880  }
8881 
8887  public static ImGuiViewportPtr FindViewportByPlatformHandle(IntPtr platformHandle)
8888  {
8889  void* nativePlatformHandle = platformHandle.ToPointer();
8890  ImGuiViewport* ret = ImGuiNative.igFindViewportByPlatformHandle(nativePlatformHandle);
8891  return new ImGuiViewportPtr(ret);
8892  }
8893 
8900  public static void GetAllocatorFunctions(ref IntPtr pAllocFunc, ref IntPtr pFreeFunc, ref void* pUserData)
8901  {
8902  fixed (IntPtr* nativePAllocFunc = &pAllocFunc)
8903  {
8904  fixed (IntPtr* nativePFreeFunc = &pFreeFunc)
8905  {
8906  fixed (void** nativePUserData = &pUserData)
8907  {
8908  ImGuiNative.igGetAllocatorFunctions(nativePAllocFunc, nativePFreeFunc, nativePUserData);
8909  }
8910  }
8911  }
8912  }
8913 
8918  public static ImDrawListPtr GetBackgroundDrawList()
8919  {
8920  ImDrawList* ret = ImGuiNative.igGetBackgroundDrawList_Nil();
8921  return new ImDrawListPtr(ret);
8922  }
8923 
8929  public static ImDrawListPtr GetBackgroundDrawList(ImGuiViewportPtr viewport)
8930  {
8931  ImGuiViewport* nativeViewport = viewport.NativePtr;
8932  ImDrawList* ret = ImGuiNative.igGetBackgroundDrawList_ViewportPtr(nativeViewport);
8933  return new ImDrawListPtr(ret);
8934  }
8935 
8940  public static string GetClipboardText()
8941  {
8942  byte* ret = ImGuiNative.igGetClipboardText();
8943  return Util.StringFromPtr(ret);
8944  }
8945 
8951  public static uint GetColorU32(ImGuiCol idx)
8952  {
8953  float alphaMul = 1.0f;
8954  uint ret = ImGuiNative.igGetColorU32_Col(idx, alphaMul);
8955  return ret;
8956  }
8957 
8964  public static uint GetColorU32(ImGuiCol idx, float alphaMul)
8965  {
8966  uint ret = ImGuiNative.igGetColorU32_Col(idx, alphaMul);
8967  return ret;
8968  }
8969 
8975  public static uint GetColorU32(Vector4F col)
8976  {
8977  uint ret = ImGuiNative.igGetColorU32_Vec4(col);
8978  return ret;
8979  }
8980 
8986  public static uint GetColorU32(uint col)
8987  {
8988  uint ret = ImGuiNative.igGetColorU32_U32(col);
8989  return ret;
8990  }
8991 
8996  public static int GetColumnIndex()
8997  {
8998  int ret = ImGuiNative.igGetColumnIndex();
8999  return ret;
9000  }
9001 
9006  public static float GetColumnOffset()
9007  {
9008  int columnIndex = -1;
9009  float ret = ImGuiNative.igGetColumnOffset(columnIndex);
9010  return ret;
9011  }
9012 
9018  public static float GetColumnOffset(int columnIndex)
9019  {
9020  float ret = ImGuiNative.igGetColumnOffset(columnIndex);
9021  return ret;
9022  }
9023 
9028  public static int GetColumnsCount()
9029  {
9030  int ret = ImGuiNative.igGetColumnsCount();
9031  return ret;
9032  }
9033 
9038  public static float GetColumnWidth()
9039  {
9040  int columnIndex = -1;
9041  float ret = ImGuiNative.igGetColumnWidth(columnIndex);
9042  return ret;
9043  }
9044 
9050  public static float GetColumnWidth(int columnIndex)
9051  {
9052  float ret = ImGuiNative.igGetColumnWidth(columnIndex);
9053  return ret;
9054  }
9055 
9060  public static Vector2F GetContentRegionAvail()
9061  {
9062  Vector2F retval;
9063  ImGuiNative.igGetContentRegionAvail(&retval);
9064  return retval;
9065  }
9066 
9071  public static Vector2F GetContentRegionMax()
9072  {
9073  Vector2F retval;
9074  ImGuiNative.igGetContentRegionMax(&retval);
9075  return retval;
9076  }
9077 
9082  public static IntPtr GetCurrentContext()
9083  {
9084  IntPtr ret = ImGuiNative.igGetCurrentContext();
9085  return ret;
9086  }
9087 
9092  public static Vector2F GetCursorPos()
9093  {
9094  Vector2F retval;
9095  ImGuiNative.igGetCursorPos(&retval);
9096  return retval;
9097  }
9098 
9103  public static float GetCursorPosX()
9104  {
9105  float ret = ImGuiNative.igGetCursorPosX();
9106  return ret;
9107  }
9108 
9113  public static float GetCursorPosY()
9114  {
9115  float ret = ImGuiNative.igGetCursorPosY();
9116  return ret;
9117  }
9118 
9123  public static Vector2F GetCursorScreenPos()
9124  {
9125  Vector2F retval;
9126  ImGuiNative.igGetCursorScreenPos(&retval);
9127  return retval;
9128  }
9129 
9134  public static Vector2F GetCursorStartPos()
9135  {
9136  Vector2F retval;
9137  ImGuiNative.igGetCursorStartPos(&retval);
9138  return retval;
9139  }
9140 
9145  public static ImGuiPayloadPtr GetDragDropPayload()
9146  {
9147  ImGuiPayload* ret = ImGuiNative.igGetDragDropPayload();
9148  return new ImGuiPayloadPtr(ret);
9149  }
9150 
9155  public static ImDrawDataPtr GetDrawData()
9156  {
9157  ImDrawData* ret = ImGuiNative.igGetDrawData();
9158  return new ImDrawDataPtr(ret);
9159  }
9160 
9165  public static IntPtr GetDrawListSharedData()
9166  {
9167  IntPtr ret = ImGuiNative.igGetDrawListSharedData();
9168  return ret;
9169  }
9170 
9175  public static ImFontPtr GetFont()
9176  {
9177  ImFont* ret = ImGuiNative.igGetFont();
9178  return new ImFontPtr(ret);
9179  }
9180 
9185  public static float GetFontSize()
9186  {
9187  float ret = ImGuiNative.igGetFontSize();
9188  return ret;
9189  }
9190 
9195  public static Vector2F GetFontTexUvWhitePixel()
9196  {
9197  Vector2F retval;
9198  ImGuiNative.igGetFontTexUvWhitePixel(&retval);
9199  return retval;
9200  }
9201 
9206  public static ImDrawListPtr GetForegroundDrawList()
9207  {
9208  ImDrawList* ret = ImGuiNative.igGetForegroundDrawList_Nil();
9209  return new ImDrawListPtr(ret);
9210  }
9211 
9217  public static ImDrawListPtr GetForegroundDrawList(ImGuiViewportPtr viewport)
9218  {
9219  ImGuiViewport* nativeViewport = viewport.NativePtr;
9220  ImDrawList* ret = ImGuiNative.igGetForegroundDrawList_ViewportPtr(nativeViewport);
9221  return new ImDrawListPtr(ret);
9222  }
9223 
9228  public static int GetFrameCount()
9229  {
9230  int ret = ImGuiNative.igGetFrameCount();
9231  return ret;
9232  }
9233 
9238  public static float GetFrameHeight()
9239  {
9240  float ret = ImGuiNative.igGetFrameHeight();
9241  return ret;
9242  }
9243 
9248  public static float GetFrameHeightWithSpacing()
9249  {
9250  float ret = ImGuiNative.igGetFrameHeightWithSpacing();
9251  return ret;
9252  }
9253 
9259  public static uint GetId(string strId)
9260  {
9261  byte* nativeStrId;
9262  int strIdByteCount = 0;
9263  if (strId != null)
9264  {
9265  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9266  if (strIdByteCount > Util.StackAllocationSizeLimit)
9267  {
9268  nativeStrId = Util.Allocate(strIdByteCount + 1);
9269  }
9270  else
9271  {
9272  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9273  nativeStrId = nativeStrIdStackBytes;
9274  }
9275 
9276  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9277  nativeStrId[nativeStrIdOffset] = 0;
9278  }
9279  else
9280  {
9281  nativeStrId = null;
9282  }
9283 
9284  uint ret = ImGuiNative.igGetID_Str(nativeStrId);
9285  if (strIdByteCount > Util.StackAllocationSizeLimit)
9286  {
9287  Util.Free(nativeStrId);
9288  }
9289 
9290  return ret;
9291  }
9292 
9298  public static uint GetId(IntPtr ptrId)
9299  {
9300  void* nativePtrId = ptrId.ToPointer();
9301  uint ret = ImGuiNative.igGetID_Ptr(nativePtrId);
9302  return ret;
9303  }
9304 
9309  public static ImGuiIoPtr GetIo()
9310  {
9311  ImGuiIo* ret = ImGuiNative.igGetIO();
9312  return new ImGuiIoPtr(ret);
9313  }
9314 
9319  public static uint GetItemId()
9320  {
9321  uint ret = ImGuiNative.igGetItemID();
9322  return ret;
9323  }
9324 
9329  public static Vector2F GetItemRectMax()
9330  {
9331  Vector2F retval;
9332  ImGuiNative.igGetItemRectMax(&retval);
9333  return retval;
9334  }
9335 
9340  public static Vector2F GetItemRectMin()
9341  {
9342  Vector2F retval;
9343  ImGuiNative.igGetItemRectMin(&retval);
9344  return retval;
9345  }
9346 
9351  public static Vector2F GetItemRectSize()
9352  {
9353  Vector2F retval;
9354  ImGuiNative.igGetItemRectSize(&retval);
9355  return retval;
9356  }
9357 
9363  public static ImGuiKey GetKeyIndex(ImGuiKey key)
9364  {
9365  ImGuiKey ret = ImGuiNative.igGetKeyIndex(key);
9366  return ret;
9367  }
9368 
9374  public static string GetKeyName(ImGuiKey key)
9375  {
9376  byte* ret = ImGuiNative.igGetKeyName(key);
9377  return Util.StringFromPtr(ret);
9378  }
9379 
9387  public static int GetKeyPressedAmount(ImGuiKey key, float repeatDelay, float rate)
9388  {
9389  int ret = ImGuiNative.igGetKeyPressedAmount(key, repeatDelay, rate);
9390  return ret;
9391  }
9392 
9397  public static ImGuiViewportPtr GetMainViewport()
9398  {
9399  ImGuiViewport* ret = ImGuiNative.igGetMainViewport();
9400  return new ImGuiViewportPtr(ret);
9401  }
9402 
9408  public static int GetMouseClickedCount(ImGuiMouseButton button)
9409  {
9410  int ret = ImGuiNative.igGetMouseClickedCount(button);
9411  return ret;
9412  }
9413 
9418  public static ImGuiMouseCursor GetMouseCursor()
9419  {
9420  ImGuiMouseCursor ret = ImGuiNative.igGetMouseCursor();
9421  return ret;
9422  }
9423 
9428  public static Vector2F GetMouseDragDelta()
9429  {
9430  Vector2F retval;
9431  ImGuiMouseButton button = 0;
9432  float lockThreshold = -1.0f;
9433  ImGuiNative.igGetMouseDragDelta(&retval, button, lockThreshold);
9434  return retval;
9435  }
9436 
9442  public static Vector2F GetMouseDragDelta(ImGuiMouseButton button)
9443  {
9444  Vector2F retval;
9445  float lockThreshold = -1.0f;
9446  ImGuiNative.igGetMouseDragDelta(&retval, button, lockThreshold);
9447  return retval;
9448  }
9449 
9456  public static Vector2F GetMouseDragDelta(ImGuiMouseButton button, float lockThreshold)
9457  {
9458  Vector2F retval;
9459  ImGuiNative.igGetMouseDragDelta(&retval, button, lockThreshold);
9460  return retval;
9461  }
9462 
9467  public static Vector2F GetMousePos()
9468  {
9469  Vector2F retval;
9470  ImGuiNative.igGetMousePos(&retval);
9471  return retval;
9472  }
9473 
9478  public static Vector2F GetMousePosOnOpeningCurrentPopup()
9479  {
9480  Vector2F retval;
9481  ImGuiNative.igGetMousePosOnOpeningCurrentPopup(&retval);
9482  return retval;
9483  }
9484 
9489  public static ImGuiPlatformIoPtr GetPlatformIo()
9490  {
9491  ImGuiPlatformIo* ret = ImGuiNative.igGetPlatformIO();
9492  return new ImGuiPlatformIoPtr(ret);
9493  }
9494 
9499  public static float GetScrollMaxX()
9500  {
9501  float ret = ImGuiNative.igGetScrollMaxX();
9502  return ret;
9503  }
9504 
9509  public static float GetScrollMaxY()
9510  {
9511  float ret = ImGuiNative.igGetScrollMaxY();
9512  return ret;
9513  }
9514 
9519  public static float GetScrollX()
9520  {
9521  float ret = ImGuiNative.igGetScrollX();
9522  return ret;
9523  }
9524 
9529  public static float GetScrollY()
9530  {
9531  float ret = ImGuiNative.igGetScrollY();
9532  return ret;
9533  }
9534 
9539  public static ImGuiStoragePtr GetStateStorage()
9540  {
9541  ImGuiStorage* ret = ImGuiNative.igGetStateStorage();
9542  return new ImGuiStoragePtr(ret);
9543  }
9544 
9549  public static ImGuiStylePtr GetStyle()
9550  {
9551  ImGuiStyle* ret = ImGuiNative.igGetStyle();
9552  return new ImGuiStylePtr(ret);
9553  }
9554 
9560  public static string GetStyleColorName(ImGuiCol idx)
9561  {
9562  byte* ret = ImGuiNative.igGetStyleColorName(idx);
9563  return Util.StringFromPtr(ret);
9564  }
9565 
9571  public static Vector4F* GetStyleColorVec4(ImGuiCol idx)
9572  {
9573  Vector4F* ret = ImGuiNative.igGetStyleColorVec4(idx);
9574  return ret;
9575  }
9576 
9581  public static float GetTextLineHeight()
9582  {
9583  float ret = ImGuiNative.igGetTextLineHeight();
9584  return ret;
9585  }
9586 
9591  public static float GetTextLineHeightWithSpacing()
9592  {
9593  float ret = ImGuiNative.igGetTextLineHeightWithSpacing();
9594  return ret;
9595  }
9596 
9601  public static double GetTime()
9602  {
9603  double ret = ImGuiNative.igGetTime();
9604  return ret;
9605  }
9606 
9611  public static float GetTreeNodeToLabelSpacing()
9612  {
9613  float ret = ImGuiNative.igGetTreeNodeToLabelSpacing();
9614  return ret;
9615  }
9616 
9621  public static string GetVersion()
9622  {
9623  byte* ret = ImGuiNative.igGetVersion();
9624  return Util.StringFromPtr(ret);
9625  }
9626 
9631  public static Vector2F GetWindowContentRegionMax()
9632  {
9633  Vector2F retval;
9634  ImGuiNative.igGetWindowContentRegionMax(&retval);
9635  return retval;
9636  }
9637 
9642  public static Vector2F GetWindowContentRegionMin()
9643  {
9644  Vector2F retval;
9645  ImGuiNative.igGetWindowContentRegionMin(&retval);
9646  return retval;
9647  }
9648 
9653  public static uint GetWindowDockId()
9654  {
9655  uint ret = ImGuiNative.igGetWindowDockID();
9656  return ret;
9657  }
9658 
9663  public static float GetWindowDpiScale()
9664  {
9665  float ret = ImGuiNative.igGetWindowDpiScale();
9666  return ret;
9667  }
9668 
9673  public static ImDrawListPtr GetWindowDrawList()
9674  {
9675  ImDrawList* ret = ImGuiNative.igGetWindowDrawList();
9676  return new ImDrawListPtr(ret);
9677  }
9678 
9683  public static float GetWindowHeight()
9684  {
9685  float ret = ImGuiNative.igGetWindowHeight();
9686  return ret;
9687  }
9688 
9693  public static Vector2F GetWindowPos()
9694  {
9695  Vector2F retval;
9696  ImGuiNative.igGetWindowPos(&retval);
9697  return retval;
9698  }
9699 
9704  public static Vector2F GetWindowSize()
9705  {
9706  Vector2F retval;
9707  ImGuiNative.igGetWindowSize(&retval);
9708  return retval;
9709  }
9710 
9715  public static ImGuiViewportPtr GetWindowViewport()
9716  {
9717  ImGuiViewport* ret = ImGuiNative.igGetWindowViewport();
9718  return new ImGuiViewportPtr(ret);
9719  }
9720 
9725  public static float GetWindowWidth()
9726  {
9727  float ret = ImGuiNative.igGetWindowWidth();
9728  return ret;
9729  }
9730 
9736  public static void Image(IntPtr userTextureId, Vector2F size)
9737  {
9738  Vector2F uv0 = new Vector2F();
9739  Vector2F uv1 = new Vector2F(1, 1);
9740  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9741  Vector4F borderCol = new Vector4F();
9742  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9743  }
9744 
9751  public static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0)
9752  {
9753  Vector2F uv1 = new Vector2F(1, 1);
9754  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9755  Vector4F borderCol = new Vector4F();
9756  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9757  }
9758 
9766  public static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1)
9767  {
9768  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9769  Vector4F borderCol = new Vector4F();
9770  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9771  }
9772 
9781  public static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol)
9782  {
9783  Vector4F borderCol = new Vector4F();
9784  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9785  }
9786 
9796  public static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol, Vector4F borderCol)
9797  {
9798  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9799  }
9800 
9808  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size)
9809  {
9810  byte* nativeStrId;
9811  int strIdByteCount = 0;
9812  if (strId != null)
9813  {
9814  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9815  if (strIdByteCount > Util.StackAllocationSizeLimit)
9816  {
9817  nativeStrId = Util.Allocate(strIdByteCount + 1);
9818  }
9819  else
9820  {
9821  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9822  nativeStrId = nativeStrIdStackBytes;
9823  }
9824 
9825  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9826  nativeStrId[nativeStrIdOffset] = 0;
9827  }
9828  else
9829  {
9830  nativeStrId = null;
9831  }
9832 
9833  Vector2F uv0 = new Vector2F();
9834  Vector2F uv1 = new Vector2F(1, 1);
9835  Vector4F bgCol = new Vector4F();
9836  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9837  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
9838  if (strIdByteCount > Util.StackAllocationSizeLimit)
9839  {
9840  Util.Free(nativeStrId);
9841  }
9842 
9843  return ret != 0;
9844  }
9845 
9854  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0)
9855  {
9856  byte* nativeStrId;
9857  int strIdByteCount = 0;
9858  if (strId != null)
9859  {
9860  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9861  if (strIdByteCount > Util.StackAllocationSizeLimit)
9862  {
9863  nativeStrId = Util.Allocate(strIdByteCount + 1);
9864  }
9865  else
9866  {
9867  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9868  nativeStrId = nativeStrIdStackBytes;
9869  }
9870 
9871  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9872  nativeStrId[nativeStrIdOffset] = 0;
9873  }
9874  else
9875  {
9876  nativeStrId = null;
9877  }
9878 
9879  Vector2F uv1 = new Vector2F(1, 1);
9880  Vector4F bgCol = new Vector4F();
9881  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9882  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
9883  if (strIdByteCount > Util.StackAllocationSizeLimit)
9884  {
9885  Util.Free(nativeStrId);
9886  }
9887 
9888  return ret != 0;
9889  }
9890 
9900  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1)
9901  {
9902  byte* nativeStrId;
9903  int strIdByteCount = 0;
9904  if (strId != null)
9905  {
9906  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9907  if (strIdByteCount > Util.StackAllocationSizeLimit)
9908  {
9909  nativeStrId = Util.Allocate(strIdByteCount + 1);
9910  }
9911  else
9912  {
9913  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9914  nativeStrId = nativeStrIdStackBytes;
9915  }
9916 
9917  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9918  nativeStrId[nativeStrIdOffset] = 0;
9919  }
9920  else
9921  {
9922  nativeStrId = null;
9923  }
9924 
9925  Vector4F bgCol = new Vector4F();
9926  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9927  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
9928  if (strIdByteCount > Util.StackAllocationSizeLimit)
9929  {
9930  Util.Free(nativeStrId);
9931  }
9932 
9933  return ret != 0;
9934  }
9935 
9946  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol)
9947  {
9948  byte* nativeStrId;
9949  int strIdByteCount = 0;
9950  if (strId != null)
9951  {
9952  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9953  if (strIdByteCount > Util.StackAllocationSizeLimit)
9954  {
9955  nativeStrId = Util.Allocate(strIdByteCount + 1);
9956  }
9957  else
9958  {
9959  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9960  nativeStrId = nativeStrIdStackBytes;
9961  }
9962 
9963  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9964  nativeStrId[nativeStrIdOffset] = 0;
9965  }
9966  else
9967  {
9968  nativeStrId = null;
9969  }
9970 
9971  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9972  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
9973  if (strIdByteCount > Util.StackAllocationSizeLimit)
9974  {
9975  Util.Free(nativeStrId);
9976  }
9977 
9978  return ret != 0;
9979  }
9980 
9992  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol, Vector4F tintCol)
9993  {
9994  byte* nativeStrId;
9995  int strIdByteCount = 0;
9996  if (strId != null)
9997  {
9998  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9999  if (strIdByteCount > Util.StackAllocationSizeLimit)
10000  {
10001  nativeStrId = Util.Allocate(strIdByteCount + 1);
10002  }
10003  else
10004  {
10005  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
10006  nativeStrId = nativeStrIdStackBytes;
10007  }
10008 
10009  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
10010  nativeStrId[nativeStrIdOffset] = 0;
10011  }
10012  else
10013  {
10014  nativeStrId = null;
10015  }
10016 
10017  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
10018  if (strIdByteCount > Util.StackAllocationSizeLimit)
10019  {
10020  Util.Free(nativeStrId);
10021  }
10022 
10023  return ret != 0;
10024  }
10025 
10029  public static void Indent()
10030  {
10031  float indentW = 0.0f;
10032  ImGuiNative.igIndent(indentW);
10033  }
10034 
10039  public static void Indent(float indentW)
10040  {
10041  ImGuiNative.igIndent(indentW);
10042  }
10043 
10050  public static bool InputDouble(string label, ref double v)
10051  {
10052  byte* nativeLabel;
10053  int labelByteCount = 0;
10054  if (label != null)
10055  {
10056  labelByteCount = Encoding.UTF8.GetByteCount(label);
10057  if (labelByteCount > Util.StackAllocationSizeLimit)
10058  {
10059  nativeLabel = Util.Allocate(labelByteCount + 1);
10060  }
10061  else
10062  {
10063  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10064  nativeLabel = nativeLabelStackBytes;
10065  }
10066 
10067  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10068  nativeLabel[nativeLabelOffset] = 0;
10069  }
10070  else
10071  {
10072  nativeLabel = null;
10073  }
10074 
10075  double step = 0.0;
10076  double stepFast = 0.0;
10077  byte* nativeFormat;
10078  int formatByteCount = 0;
10079  formatByteCount = Encoding.UTF8.GetByteCount("%.6f");
10080  if (formatByteCount > Util.StackAllocationSizeLimit)
10081  {
10082  nativeFormat = Util.Allocate(formatByteCount + 1);
10083  }
10084  else
10085  {
10086  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10087  nativeFormat = nativeFormatStackBytes;
10088  }
10089 
10090  int nativeFormatOffset = Util.GetUtf8("%.6f", nativeFormat, formatByteCount);
10091  nativeFormat[nativeFormatOffset] = 0;
10092  ImGuiInputTextFlags flags = 0;
10093  fixed (double* nativeV = &v)
10094  {
10095  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10096  if (labelByteCount > Util.StackAllocationSizeLimit)
10097  {
10098  Util.Free(nativeLabel);
10099  }
10100 
10101  if (formatByteCount > Util.StackAllocationSizeLimit)
10102  {
10103  Util.Free(nativeFormat);
10104  }
10105 
10106  return ret != 0;
10107  }
10108  }
10109 
10117  public static bool InputDouble(string label, ref double v, double step)
10118  {
10119  byte* nativeLabel;
10120  int labelByteCount = 0;
10121  if (label != null)
10122  {
10123  labelByteCount = Encoding.UTF8.GetByteCount(label);
10124  if (labelByteCount > Util.StackAllocationSizeLimit)
10125  {
10126  nativeLabel = Util.Allocate(labelByteCount + 1);
10127  }
10128  else
10129  {
10130  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10131  nativeLabel = nativeLabelStackBytes;
10132  }
10133 
10134  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10135  nativeLabel[nativeLabelOffset] = 0;
10136  }
10137  else
10138  {
10139  nativeLabel = null;
10140  }
10141 
10142  double stepFast = 0.0;
10143  byte* nativeFormat;
10144  int formatByteCount = 0;
10145  formatByteCount = Encoding.UTF8.GetByteCount("%.6f");
10146  if (formatByteCount > Util.StackAllocationSizeLimit)
10147  {
10148  nativeFormat = Util.Allocate(formatByteCount + 1);
10149  }
10150  else
10151  {
10152  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10153  nativeFormat = nativeFormatStackBytes;
10154  }
10155 
10156  int nativeFormatOffset = Util.GetUtf8("%.6f", nativeFormat, formatByteCount);
10157  nativeFormat[nativeFormatOffset] = 0;
10158  ImGuiInputTextFlags flags = 0;
10159  fixed (double* nativeV = &v)
10160  {
10161  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10162  if (labelByteCount > Util.StackAllocationSizeLimit)
10163  {
10164  Util.Free(nativeLabel);
10165  }
10166 
10167  if (formatByteCount > Util.StackAllocationSizeLimit)
10168  {
10169  Util.Free(nativeFormat);
10170  }
10171 
10172  return ret != 0;
10173  }
10174  }
10175 
10184  public static bool InputDouble(string label, ref double v, double step, double stepFast)
10185  {
10186  byte* nativeLabel;
10187  int labelByteCount = 0;
10188  if (label != null)
10189  {
10190  labelByteCount = Encoding.UTF8.GetByteCount(label);
10191  if (labelByteCount > Util.StackAllocationSizeLimit)
10192  {
10193  nativeLabel = Util.Allocate(labelByteCount + 1);
10194  }
10195  else
10196  {
10197  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10198  nativeLabel = nativeLabelStackBytes;
10199  }
10200 
10201  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10202  nativeLabel[nativeLabelOffset] = 0;
10203  }
10204  else
10205  {
10206  nativeLabel = null;
10207  }
10208 
10209  byte* nativeFormat;
10210  int formatByteCount = 0;
10211  formatByteCount = Encoding.UTF8.GetByteCount("%.6f");
10212  if (formatByteCount > Util.StackAllocationSizeLimit)
10213  {
10214  nativeFormat = Util.Allocate(formatByteCount + 1);
10215  }
10216  else
10217  {
10218  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10219  nativeFormat = nativeFormatStackBytes;
10220  }
10221 
10222  int nativeFormatOffset = Util.GetUtf8("%.6f", nativeFormat, formatByteCount);
10223  nativeFormat[nativeFormatOffset] = 0;
10224  ImGuiInputTextFlags flags = 0;
10225  fixed (double* nativeV = &v)
10226  {
10227  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10228  if (labelByteCount > Util.StackAllocationSizeLimit)
10229  {
10230  Util.Free(nativeLabel);
10231  }
10232 
10233  if (formatByteCount > Util.StackAllocationSizeLimit)
10234  {
10235  Util.Free(nativeFormat);
10236  }
10237 
10238  return ret != 0;
10239  }
10240  }
10241 
10251  public static bool InputDouble(string label, ref double v, double step, double stepFast, string format)
10252  {
10253  byte* nativeLabel;
10254  int labelByteCount = 0;
10255  if (label != null)
10256  {
10257  labelByteCount = Encoding.UTF8.GetByteCount(label);
10258  if (labelByteCount > Util.StackAllocationSizeLimit)
10259  {
10260  nativeLabel = Util.Allocate(labelByteCount + 1);
10261  }
10262  else
10263  {
10264  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10265  nativeLabel = nativeLabelStackBytes;
10266  }
10267 
10268  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10269  nativeLabel[nativeLabelOffset] = 0;
10270  }
10271  else
10272  {
10273  nativeLabel = null;
10274  }
10275 
10276  byte* nativeFormat;
10277  int formatByteCount = 0;
10278  if (format != null)
10279  {
10280  formatByteCount = Encoding.UTF8.GetByteCount(format);
10281  if (formatByteCount > Util.StackAllocationSizeLimit)
10282  {
10283  nativeFormat = Util.Allocate(formatByteCount + 1);
10284  }
10285  else
10286  {
10287  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10288  nativeFormat = nativeFormatStackBytes;
10289  }
10290 
10291  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10292  nativeFormat[nativeFormatOffset] = 0;
10293  }
10294  else
10295  {
10296  nativeFormat = null;
10297  }
10298 
10299  ImGuiInputTextFlags flags = 0;
10300  fixed (double* nativeV = &v)
10301  {
10302  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10303  if (labelByteCount > Util.StackAllocationSizeLimit)
10304  {
10305  Util.Free(nativeLabel);
10306  }
10307 
10308  if (formatByteCount > Util.StackAllocationSizeLimit)
10309  {
10310  Util.Free(nativeFormat);
10311  }
10312 
10313  return ret != 0;
10314  }
10315  }
10316 
10327  public static bool InputDouble(string label, ref double v, double step, double stepFast, string format, ImGuiInputTextFlags flags)
10328  {
10329  byte* nativeLabel;
10330  int labelByteCount = 0;
10331  if (label != null)
10332  {
10333  labelByteCount = Encoding.UTF8.GetByteCount(label);
10334  if (labelByteCount > Util.StackAllocationSizeLimit)
10335  {
10336  nativeLabel = Util.Allocate(labelByteCount + 1);
10337  }
10338  else
10339  {
10340  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10341  nativeLabel = nativeLabelStackBytes;
10342  }
10343 
10344  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10345  nativeLabel[nativeLabelOffset] = 0;
10346  }
10347  else
10348  {
10349  nativeLabel = null;
10350  }
10351 
10352  byte* nativeFormat;
10353  int formatByteCount = 0;
10354  if (format != null)
10355  {
10356  formatByteCount = Encoding.UTF8.GetByteCount(format);
10357  if (formatByteCount > Util.StackAllocationSizeLimit)
10358  {
10359  nativeFormat = Util.Allocate(formatByteCount + 1);
10360  }
10361  else
10362  {
10363  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10364  nativeFormat = nativeFormatStackBytes;
10365  }
10366 
10367  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10368  nativeFormat[nativeFormatOffset] = 0;
10369  }
10370  else
10371  {
10372  nativeFormat = null;
10373  }
10374 
10375  fixed (double* nativeV = &v)
10376  {
10377  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10378  if (labelByteCount > Util.StackAllocationSizeLimit)
10379  {
10380  Util.Free(nativeLabel);
10381  }
10382 
10383  if (formatByteCount > Util.StackAllocationSizeLimit)
10384  {
10385  Util.Free(nativeFormat);
10386  }
10387 
10388  return ret != 0;
10389  }
10390  }
10391 
10398  public static bool InputFloat(string label, ref float v)
10399  {
10400  byte* nativeLabel;
10401  int labelByteCount = 0;
10402  if (label != null)
10403  {
10404  labelByteCount = Encoding.UTF8.GetByteCount(label);
10405  if (labelByteCount > Util.StackAllocationSizeLimit)
10406  {
10407  nativeLabel = Util.Allocate(labelByteCount + 1);
10408  }
10409  else
10410  {
10411  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10412  nativeLabel = nativeLabelStackBytes;
10413  }
10414 
10415  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10416  nativeLabel[nativeLabelOffset] = 0;
10417  }
10418  else
10419  {
10420  nativeLabel = null;
10421  }
10422 
10423  float step = 0.0f;
10424  float stepFast = 0.0f;
10425  byte* nativeFormat;
10426  int formatByteCount = 0;
10427  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10428  if (formatByteCount > Util.StackAllocationSizeLimit)
10429  {
10430  nativeFormat = Util.Allocate(formatByteCount + 1);
10431  }
10432  else
10433  {
10434  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10435  nativeFormat = nativeFormatStackBytes;
10436  }
10437 
10438  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10439  nativeFormat[nativeFormatOffset] = 0;
10440  ImGuiInputTextFlags flags = 0;
10441  fixed (float* nativeV = &v)
10442  {
10443  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10444  if (labelByteCount > Util.StackAllocationSizeLimit)
10445  {
10446  Util.Free(nativeLabel);
10447  }
10448 
10449  if (formatByteCount > Util.StackAllocationSizeLimit)
10450  {
10451  Util.Free(nativeFormat);
10452  }
10453 
10454  return ret != 0;
10455  }
10456  }
10457 
10465  public static bool InputFloat(string label, ref float v, float step)
10466  {
10467  byte* nativeLabel;
10468  int labelByteCount = 0;
10469  if (label != null)
10470  {
10471  labelByteCount = Encoding.UTF8.GetByteCount(label);
10472  if (labelByteCount > Util.StackAllocationSizeLimit)
10473  {
10474  nativeLabel = Util.Allocate(labelByteCount + 1);
10475  }
10476  else
10477  {
10478  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10479  nativeLabel = nativeLabelStackBytes;
10480  }
10481 
10482  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10483  nativeLabel[nativeLabelOffset] = 0;
10484  }
10485  else
10486  {
10487  nativeLabel = null;
10488  }
10489 
10490  float stepFast = 0.0f;
10491  byte* nativeFormat;
10492  int formatByteCount = 0;
10493  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10494  if (formatByteCount > Util.StackAllocationSizeLimit)
10495  {
10496  nativeFormat = Util.Allocate(formatByteCount + 1);
10497  }
10498  else
10499  {
10500  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10501  nativeFormat = nativeFormatStackBytes;
10502  }
10503 
10504  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10505  nativeFormat[nativeFormatOffset] = 0;
10506  ImGuiInputTextFlags flags = 0;
10507  fixed (float* nativeV = &v)
10508  {
10509  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10510  if (labelByteCount > Util.StackAllocationSizeLimit)
10511  {
10512  Util.Free(nativeLabel);
10513  }
10514 
10515  if (formatByteCount > Util.StackAllocationSizeLimit)
10516  {
10517  Util.Free(nativeFormat);
10518  }
10519 
10520  return ret != 0;
10521  }
10522  }
10523 
10532  public static bool InputFloat(string label, ref float v, float step, float stepFast)
10533  {
10534  byte* nativeLabel;
10535  int labelByteCount = 0;
10536  if (label != null)
10537  {
10538  labelByteCount = Encoding.UTF8.GetByteCount(label);
10539  if (labelByteCount > Util.StackAllocationSizeLimit)
10540  {
10541  nativeLabel = Util.Allocate(labelByteCount + 1);
10542  }
10543  else
10544  {
10545  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10546  nativeLabel = nativeLabelStackBytes;
10547  }
10548 
10549  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10550  nativeLabel[nativeLabelOffset] = 0;
10551  }
10552  else
10553  {
10554  nativeLabel = null;
10555  }
10556 
10557  byte* nativeFormat;
10558  int formatByteCount = 0;
10559  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10560  if (formatByteCount > Util.StackAllocationSizeLimit)
10561  {
10562  nativeFormat = Util.Allocate(formatByteCount + 1);
10563  }
10564  else
10565  {
10566  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10567  nativeFormat = nativeFormatStackBytes;
10568  }
10569 
10570  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10571  nativeFormat[nativeFormatOffset] = 0;
10572  ImGuiInputTextFlags flags = 0;
10573  fixed (float* nativeV = &v)
10574  {
10575  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10576  if (labelByteCount > Util.StackAllocationSizeLimit)
10577  {
10578  Util.Free(nativeLabel);
10579  }
10580 
10581  if (formatByteCount > Util.StackAllocationSizeLimit)
10582  {
10583  Util.Free(nativeFormat);
10584  }
10585 
10586  return ret != 0;
10587  }
10588  }
10589 
10599  public static bool InputFloat(string label, ref float v, float step, float stepFast, string format)
10600  {
10601  byte* nativeLabel;
10602  int labelByteCount = 0;
10603  if (label != null)
10604  {
10605  labelByteCount = Encoding.UTF8.GetByteCount(label);
10606  if (labelByteCount > Util.StackAllocationSizeLimit)
10607  {
10608  nativeLabel = Util.Allocate(labelByteCount + 1);
10609  }
10610  else
10611  {
10612  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10613  nativeLabel = nativeLabelStackBytes;
10614  }
10615 
10616  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10617  nativeLabel[nativeLabelOffset] = 0;
10618  }
10619  else
10620  {
10621  nativeLabel = null;
10622  }
10623 
10624  byte* nativeFormat;
10625  int formatByteCount = 0;
10626  if (format != null)
10627  {
10628  formatByteCount = Encoding.UTF8.GetByteCount(format);
10629  if (formatByteCount > Util.StackAllocationSizeLimit)
10630  {
10631  nativeFormat = Util.Allocate(formatByteCount + 1);
10632  }
10633  else
10634  {
10635  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10636  nativeFormat = nativeFormatStackBytes;
10637  }
10638 
10639  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10640  nativeFormat[nativeFormatOffset] = 0;
10641  }
10642  else
10643  {
10644  nativeFormat = null;
10645  }
10646 
10647  ImGuiInputTextFlags flags = 0;
10648  fixed (float* nativeV = &v)
10649  {
10650  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10651  if (labelByteCount > Util.StackAllocationSizeLimit)
10652  {
10653  Util.Free(nativeLabel);
10654  }
10655 
10656  if (formatByteCount > Util.StackAllocationSizeLimit)
10657  {
10658  Util.Free(nativeFormat);
10659  }
10660 
10661  return ret != 0;
10662  }
10663  }
10664 
10675  public static bool InputFloat(string label, ref float v, float step, float stepFast, string format, ImGuiInputTextFlags flags)
10676  {
10677  byte* nativeLabel;
10678  int labelByteCount = 0;
10679  if (label != null)
10680  {
10681  labelByteCount = Encoding.UTF8.GetByteCount(label);
10682  if (labelByteCount > Util.StackAllocationSizeLimit)
10683  {
10684  nativeLabel = Util.Allocate(labelByteCount + 1);
10685  }
10686  else
10687  {
10688  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10689  nativeLabel = nativeLabelStackBytes;
10690  }
10691 
10692  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10693  nativeLabel[nativeLabelOffset] = 0;
10694  }
10695  else
10696  {
10697  nativeLabel = null;
10698  }
10699 
10700  byte* nativeFormat;
10701  int formatByteCount = 0;
10702  if (format != null)
10703  {
10704  formatByteCount = Encoding.UTF8.GetByteCount(format);
10705  if (formatByteCount > Util.StackAllocationSizeLimit)
10706  {
10707  nativeFormat = Util.Allocate(formatByteCount + 1);
10708  }
10709  else
10710  {
10711  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10712  nativeFormat = nativeFormatStackBytes;
10713  }
10714 
10715  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10716  nativeFormat[nativeFormatOffset] = 0;
10717  }
10718  else
10719  {
10720  nativeFormat = null;
10721  }
10722 
10723  fixed (float* nativeV = &v)
10724  {
10725  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flags);
10726  if (labelByteCount > Util.StackAllocationSizeLimit)
10727  {
10728  Util.Free(nativeLabel);
10729  }
10730 
10731  if (formatByteCount > Util.StackAllocationSizeLimit)
10732  {
10733  Util.Free(nativeFormat);
10734  }
10735 
10736  return ret != 0;
10737  }
10738  }
10739 
10746  public static bool InputFloat2(string label, ref Vector2F v)
10747  {
10748  byte* nativeLabel;
10749  int labelByteCount = 0;
10750  if (label != null)
10751  {
10752  labelByteCount = Encoding.UTF8.GetByteCount(label);
10753  if (labelByteCount > Util.StackAllocationSizeLimit)
10754  {
10755  nativeLabel = Util.Allocate(labelByteCount + 1);
10756  }
10757  else
10758  {
10759  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10760  nativeLabel = nativeLabelStackBytes;
10761  }
10762 
10763  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10764  nativeLabel[nativeLabelOffset] = 0;
10765  }
10766  else
10767  {
10768  nativeLabel = null;
10769  }
10770 
10771  byte* nativeFormat;
10772  int formatByteCount = 0;
10773  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10774  if (formatByteCount > Util.StackAllocationSizeLimit)
10775  {
10776  nativeFormat = Util.Allocate(formatByteCount + 1);
10777  }
10778  else
10779  {
10780  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10781  nativeFormat = nativeFormatStackBytes;
10782  }
10783 
10784  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10785  nativeFormat[nativeFormatOffset] = 0;
10786  ImGuiInputTextFlags flags = 0;
10787  fixed (Vector2F* nativeV = &v)
10788  {
10789  byte ret = ImGuiNative.igInputFloat2(nativeLabel, nativeV, nativeFormat, flags);
10790  if (labelByteCount > Util.StackAllocationSizeLimit)
10791  {
10792  Util.Free(nativeLabel);
10793  }
10794 
10795  if (formatByteCount > Util.StackAllocationSizeLimit)
10796  {
10797  Util.Free(nativeFormat);
10798  }
10799 
10800  return ret != 0;
10801  }
10802  }
10803 
10811  public static bool InputFloat2(string label, ref Vector2F v, string format)
10812  {
10813  byte* nativeLabel;
10814  int labelByteCount = 0;
10815  if (label != null)
10816  {
10817  labelByteCount = Encoding.UTF8.GetByteCount(label);
10818  if (labelByteCount > Util.StackAllocationSizeLimit)
10819  {
10820  nativeLabel = Util.Allocate(labelByteCount + 1);
10821  }
10822  else
10823  {
10824  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10825  nativeLabel = nativeLabelStackBytes;
10826  }
10827 
10828  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10829  nativeLabel[nativeLabelOffset] = 0;
10830  }
10831  else
10832  {
10833  nativeLabel = null;
10834  }
10835 
10836  byte* nativeFormat;
10837  int formatByteCount = 0;
10838  if (format != null)
10839  {
10840  formatByteCount = Encoding.UTF8.GetByteCount(format);
10841  if (formatByteCount > Util.StackAllocationSizeLimit)
10842  {
10843  nativeFormat = Util.Allocate(formatByteCount + 1);
10844  }
10845  else
10846  {
10847  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10848  nativeFormat = nativeFormatStackBytes;
10849  }
10850 
10851  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10852  nativeFormat[nativeFormatOffset] = 0;
10853  }
10854  else
10855  {
10856  nativeFormat = null;
10857  }
10858 
10859  ImGuiInputTextFlags flags = 0;
10860  fixed (Vector2F* nativeV = &v)
10861  {
10862  byte ret = ImGuiNative.igInputFloat2(nativeLabel, nativeV, nativeFormat, flags);
10863  if (labelByteCount > Util.StackAllocationSizeLimit)
10864  {
10865  Util.Free(nativeLabel);
10866  }
10867 
10868  if (formatByteCount > Util.StackAllocationSizeLimit)
10869  {
10870  Util.Free(nativeFormat);
10871  }
10872 
10873  return ret != 0;
10874  }
10875  }
10876 
10885  public static bool InputFloat2(string label, ref Vector2F v, string format, ImGuiInputTextFlags flags)
10886  {
10887  byte* nativeLabel;
10888  int labelByteCount = 0;
10889  if (label != null)
10890  {
10891  labelByteCount = Encoding.UTF8.GetByteCount(label);
10892  if (labelByteCount > Util.StackAllocationSizeLimit)
10893  {
10894  nativeLabel = Util.Allocate(labelByteCount + 1);
10895  }
10896  else
10897  {
10898  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10899  nativeLabel = nativeLabelStackBytes;
10900  }
10901 
10902  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10903  nativeLabel[nativeLabelOffset] = 0;
10904  }
10905  else
10906  {
10907  nativeLabel = null;
10908  }
10909 
10910  byte* nativeFormat;
10911  int formatByteCount = 0;
10912  if (format != null)
10913  {
10914  formatByteCount = Encoding.UTF8.GetByteCount(format);
10915  if (formatByteCount > Util.StackAllocationSizeLimit)
10916  {
10917  nativeFormat = Util.Allocate(formatByteCount + 1);
10918  }
10919  else
10920  {
10921  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10922  nativeFormat = nativeFormatStackBytes;
10923  }
10924 
10925  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10926  nativeFormat[nativeFormatOffset] = 0;
10927  }
10928  else
10929  {
10930  nativeFormat = null;
10931  }
10932 
10933  fixed (Vector2F* nativeV = &v)
10934  {
10935  byte ret = ImGuiNative.igInputFloat2(nativeLabel, nativeV, nativeFormat, flags);
10936  if (labelByteCount > Util.StackAllocationSizeLimit)
10937  {
10938  Util.Free(nativeLabel);
10939  }
10940 
10941  if (formatByteCount > Util.StackAllocationSizeLimit)
10942  {
10943  Util.Free(nativeFormat);
10944  }
10945 
10946  return ret != 0;
10947  }
10948  }
10949 
10956  public static bool InputFloat3(string label, ref Vector3F v)
10957  {
10958  byte* nativeLabel;
10959  int labelByteCount = 0;
10960  if (label != null)
10961  {
10962  labelByteCount = Encoding.UTF8.GetByteCount(label);
10963  if (labelByteCount > Util.StackAllocationSizeLimit)
10964  {
10965  nativeLabel = Util.Allocate(labelByteCount + 1);
10966  }
10967  else
10968  {
10969  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10970  nativeLabel = nativeLabelStackBytes;
10971  }
10972 
10973  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10974  nativeLabel[nativeLabelOffset] = 0;
10975  }
10976  else
10977  {
10978  nativeLabel = null;
10979  }
10980 
10981  byte* nativeFormat;
10982  int formatByteCount = 0;
10983  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10984  if (formatByteCount > Util.StackAllocationSizeLimit)
10985  {
10986  nativeFormat = Util.Allocate(formatByteCount + 1);
10987  }
10988  else
10989  {
10990  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10991  nativeFormat = nativeFormatStackBytes;
10992  }
10993 
10994  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10995  nativeFormat[nativeFormatOffset] = 0;
10996  ImGuiInputTextFlags flags = 0;
10997  fixed (Vector3F* nativeV = &v)
10998  {
10999  byte ret = ImGuiNative.igInputFloat3(nativeLabel, nativeV, nativeFormat, flags);
11000  if (labelByteCount > Util.StackAllocationSizeLimit)
11001  {
11002  Util.Free(nativeLabel);
11003  }
11004 
11005  if (formatByteCount > Util.StackAllocationSizeLimit)
11006  {
11007  Util.Free(nativeFormat);
11008  }
11009 
11010  return ret != 0;
11011  }
11012  }
11013 
11021  public static bool InputFloat3(string label, ref Vector3F v, string format)
11022  {
11023  byte* nativeLabel;
11024  int labelByteCount = 0;
11025  if (label != null)
11026  {
11027  labelByteCount = Encoding.UTF8.GetByteCount(label);
11028  if (labelByteCount > Util.StackAllocationSizeLimit)
11029  {
11030  nativeLabel = Util.Allocate(labelByteCount + 1);
11031  }
11032  else
11033  {
11034  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11035  nativeLabel = nativeLabelStackBytes;
11036  }
11037 
11038  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11039  nativeLabel[nativeLabelOffset] = 0;
11040  }
11041  else
11042  {
11043  nativeLabel = null;
11044  }
11045 
11046  byte* nativeFormat;
11047  int formatByteCount = 0;
11048  if (format != null)
11049  {
11050  formatByteCount = Encoding.UTF8.GetByteCount(format);
11051  if (formatByteCount > Util.StackAllocationSizeLimit)
11052  {
11053  nativeFormat = Util.Allocate(formatByteCount + 1);
11054  }
11055  else
11056  {
11057  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11058  nativeFormat = nativeFormatStackBytes;
11059  }
11060 
11061  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
11062  nativeFormat[nativeFormatOffset] = 0;
11063  }
11064  else
11065  {
11066  nativeFormat = null;
11067  }
11068 
11069  ImGuiInputTextFlags flags = 0;
11070  fixed (Vector3F* nativeV = &v)
11071  {
11072  byte ret = ImGuiNative.igInputFloat3(nativeLabel, nativeV, nativeFormat, flags);
11073  if (labelByteCount > Util.StackAllocationSizeLimit)
11074  {
11075  Util.Free(nativeLabel);
11076  }
11077 
11078  if (formatByteCount > Util.StackAllocationSizeLimit)
11079  {
11080  Util.Free(nativeFormat);
11081  }
11082 
11083  return ret != 0;
11084  }
11085  }
11086 
11095  public static bool InputFloat3(string label, ref Vector3F v, string format, ImGuiInputTextFlags flags)
11096  {
11097  byte* nativeLabel;
11098  int labelByteCount = 0;
11099  if (label != null)
11100  {
11101  labelByteCount = Encoding.UTF8.GetByteCount(label);
11102  if (labelByteCount > Util.StackAllocationSizeLimit)
11103  {
11104  nativeLabel = Util.Allocate(labelByteCount + 1);
11105  }
11106  else
11107  {
11108  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11109  nativeLabel = nativeLabelStackBytes;
11110  }
11111 
11112  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11113  nativeLabel[nativeLabelOffset] = 0;
11114  }
11115  else
11116  {
11117  nativeLabel = null;
11118  }
11119 
11120  byte* nativeFormat;
11121  int formatByteCount = 0;
11122  if (format != null)
11123  {
11124  formatByteCount = Encoding.UTF8.GetByteCount(format);
11125  if (formatByteCount > Util.StackAllocationSizeLimit)
11126  {
11127  nativeFormat = Util.Allocate(formatByteCount + 1);
11128  }
11129  else
11130  {
11131  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11132  nativeFormat = nativeFormatStackBytes;
11133  }
11134 
11135  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
11136  nativeFormat[nativeFormatOffset] = 0;
11137  }
11138  else
11139  {
11140  nativeFormat = null;
11141  }
11142 
11143  fixed (Vector3F* nativeV = &v)
11144  {
11145  byte ret = ImGuiNative.igInputFloat3(nativeLabel, nativeV, nativeFormat, flags);
11146  if (labelByteCount > Util.StackAllocationSizeLimit)
11147  {
11148  Util.Free(nativeLabel);
11149  }
11150 
11151  if (formatByteCount > Util.StackAllocationSizeLimit)
11152  {
11153  Util.Free(nativeFormat);
11154  }
11155 
11156  return ret != 0;
11157  }
11158  }
11159 
11166  public static bool InputFloat4(string label, ref Vector4F v)
11167  {
11168  byte* nativeLabel;
11169  int labelByteCount = 0;
11170  if (label != null)
11171  {
11172  labelByteCount = Encoding.UTF8.GetByteCount(label);
11173  if (labelByteCount > Util.StackAllocationSizeLimit)
11174  {
11175  nativeLabel = Util.Allocate(labelByteCount + 1);
11176  }
11177  else
11178  {
11179  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11180  nativeLabel = nativeLabelStackBytes;
11181  }
11182 
11183  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11184  nativeLabel[nativeLabelOffset] = 0;
11185  }
11186  else
11187  {
11188  nativeLabel = null;
11189  }
11190 
11191  byte* nativeFormat;
11192  int formatByteCount = 0;
11193  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
11194  if (formatByteCount > Util.StackAllocationSizeLimit)
11195  {
11196  nativeFormat = Util.Allocate(formatByteCount + 1);
11197  }
11198  else
11199  {
11200  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11201  nativeFormat = nativeFormatStackBytes;
11202  }
11203 
11204  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
11205  nativeFormat[nativeFormatOffset] = 0;
11206  ImGuiInputTextFlags flags = 0;
11207  fixed (Vector4F* nativeV = &v)
11208  {
11209  byte ret = ImGuiNative.igInputFloat4(nativeLabel, nativeV, nativeFormat, flags);
11210  if (labelByteCount > Util.StackAllocationSizeLimit)
11211  {
11212  Util.Free(nativeLabel);
11213  }
11214 
11215  if (formatByteCount > Util.StackAllocationSizeLimit)
11216  {
11217  Util.Free(nativeFormat);
11218  }
11219 
11220  return ret != 0;
11221  }
11222  }
11223 
11231  public static bool InputFloat4(string label, ref Vector4F v, string format)
11232  {
11233  byte* nativeLabel;
11234  int labelByteCount = 0;
11235  if (label != null)
11236  {
11237  labelByteCount = Encoding.UTF8.GetByteCount(label);
11238  if (labelByteCount > Util.StackAllocationSizeLimit)
11239  {
11240  nativeLabel = Util.Allocate(labelByteCount + 1);
11241  }
11242  else
11243  {
11244  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11245  nativeLabel = nativeLabelStackBytes;
11246  }
11247 
11248  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11249  nativeLabel[nativeLabelOffset] = 0;
11250  }
11251  else
11252  {
11253  nativeLabel = null;
11254  }
11255 
11256  byte* nativeFormat;
11257  int formatByteCount = 0;
11258  if (format != null)
11259  {
11260  formatByteCount = Encoding.UTF8.GetByteCount(format);
11261  if (formatByteCount > Util.StackAllocationSizeLimit)
11262  {
11263  nativeFormat = Util.Allocate(formatByteCount + 1);
11264  }
11265  else
11266  {
11267  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11268  nativeFormat = nativeFormatStackBytes;
11269  }
11270 
11271  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
11272  nativeFormat[nativeFormatOffset] = 0;
11273  }
11274  else
11275  {
11276  nativeFormat = null;
11277  }
11278 
11279  ImGuiInputTextFlags flags = 0;
11280  fixed (Vector4F* nativeV = &v)
11281  {
11282  byte ret = ImGuiNative.igInputFloat4(nativeLabel, nativeV, nativeFormat, flags);
11283  if (labelByteCount > Util.StackAllocationSizeLimit)
11284  {
11285  Util.Free(nativeLabel);
11286  }
11287 
11288  if (formatByteCount > Util.StackAllocationSizeLimit)
11289  {
11290  Util.Free(nativeFormat);
11291  }
11292 
11293  return ret != 0;
11294  }
11295  }
11296 
11305  public static bool InputFloat4(string label, ref Vector4F v, string format, ImGuiInputTextFlags flags)
11306  {
11307  byte* nativeLabel;
11308  int labelByteCount = 0;
11309  if (label != null)
11310  {
11311  labelByteCount = Encoding.UTF8.GetByteCount(label);
11312  if (labelByteCount > Util.StackAllocationSizeLimit)
11313  {
11314  nativeLabel = Util.Allocate(labelByteCount + 1);
11315  }
11316  else
11317  {
11318  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11319  nativeLabel = nativeLabelStackBytes;
11320  }
11321 
11322  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11323  nativeLabel[nativeLabelOffset] = 0;
11324  }
11325  else
11326  {
11327  nativeLabel = null;
11328  }
11329 
11330  byte* nativeFormat;
11331  int formatByteCount = 0;
11332  if (format != null)
11333  {
11334  formatByteCount = Encoding.UTF8.GetByteCount(format);
11335  if (formatByteCount > Util.StackAllocationSizeLimit)
11336  {
11337  nativeFormat = Util.Allocate(formatByteCount + 1);
11338  }
11339  else
11340  {
11341  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11342  nativeFormat = nativeFormatStackBytes;
11343  }
11344 
11345  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
11346  nativeFormat[nativeFormatOffset] = 0;
11347  }
11348  else
11349  {
11350  nativeFormat = null;
11351  }
11352 
11353  fixed (Vector4F* nativeV = &v)
11354  {
11355  byte ret = ImGuiNative.igInputFloat4(nativeLabel, nativeV, nativeFormat, flags);
11356  if (labelByteCount > Util.StackAllocationSizeLimit)
11357  {
11358  Util.Free(nativeLabel);
11359  }
11360 
11361  if (formatByteCount > Util.StackAllocationSizeLimit)
11362  {
11363  Util.Free(nativeFormat);
11364  }
11365 
11366  return ret != 0;
11367  }
11368  }
11369 
11376  public static bool InputInt(string label, ref int v)
11377  {
11378  byte* nativeLabel;
11379  int labelByteCount = 0;
11380  if (label != null)
11381  {
11382  labelByteCount = Encoding.UTF8.GetByteCount(label);
11383  if (labelByteCount > Util.StackAllocationSizeLimit)
11384  {
11385  nativeLabel = Util.Allocate(labelByteCount + 1);
11386  }
11387  else
11388  {
11389  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11390  nativeLabel = nativeLabelStackBytes;
11391  }
11392 
11393  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11394  nativeLabel[nativeLabelOffset] = 0;
11395  }
11396  else
11397  {
11398  nativeLabel = null;
11399  }
11400 
11401  int step = 1;
11402  int stepFast = 100;
11403  ImGuiInputTextFlags flags = 0;
11404  fixed (int* nativeV = &v)
11405  {
11406  byte ret = ImGuiNative.igInputInt(nativeLabel, nativeV, step, stepFast, flags);
11407  if (labelByteCount > Util.StackAllocationSizeLimit)
11408  {
11409  Util.Free(nativeLabel);
11410  }
11411 
11412  return ret != 0;
11413  }
11414  }
11415 
11423  public static bool InputInt(string label, ref int v, int step)
11424  {
11425  byte* nativeLabel;
11426  int labelByteCount = 0;
11427  if (label != null)
11428  {
11429  labelByteCount = Encoding.UTF8.GetByteCount(label);
11430  if (labelByteCount > Util.StackAllocationSizeLimit)
11431  {
11432  nativeLabel = Util.Allocate(labelByteCount + 1);
11433  }
11434  else
11435  {
11436  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11437  nativeLabel = nativeLabelStackBytes;
11438  }
11439 
11440  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11441  nativeLabel[nativeLabelOffset] = 0;
11442  }
11443  else
11444  {
11445  nativeLabel = null;
11446  }
11447 
11448  int stepFast = 100;
11449  ImGuiInputTextFlags flags = 0;
11450  fixed (int* nativeV = &v)
11451  {
11452  byte ret = ImGuiNative.igInputInt(nativeLabel, nativeV, step, stepFast, flags);
11453  if (labelByteCount > Util.StackAllocationSizeLimit)
11454  {
11455  Util.Free(nativeLabel);
11456  }
11457 
11458  return ret != 0;
11459  }
11460  }
11461 
11470  public static bool InputInt(string label, ref int v, int step, int stepFast)
11471  {
11472  byte* nativeLabel;
11473  int labelByteCount = 0;
11474  if (label != null)
11475  {
11476  labelByteCount = Encoding.UTF8.GetByteCount(label);
11477  if (labelByteCount > Util.StackAllocationSizeLimit)
11478  {
11479  nativeLabel = Util.Allocate(labelByteCount + 1);
11480  }
11481  else
11482  {
11483  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11484  nativeLabel = nativeLabelStackBytes;
11485  }
11486 
11487  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11488  nativeLabel[nativeLabelOffset] = 0;
11489  }
11490  else
11491  {
11492  nativeLabel = null;
11493  }
11494 
11495  ImGuiInputTextFlags flags = 0;
11496  fixed (int* nativeV = &v)
11497  {
11498  byte ret = ImGuiNative.igInputInt(nativeLabel, nativeV, step, stepFast, flags);
11499  if (labelByteCount > Util.StackAllocationSizeLimit)
11500  {
11501  Util.Free(nativeLabel);
11502  }
11503 
11504  return ret != 0;
11505  }
11506  }
11507 
11517  public static bool InputInt(string label, ref int v, int step, int stepFast, ImGuiInputTextFlags flags)
11518  {
11519  byte* nativeLabel;
11520  int labelByteCount = 0;
11521  if (label != null)
11522  {
11523  labelByteCount = Encoding.UTF8.GetByteCount(label);
11524  if (labelByteCount > Util.StackAllocationSizeLimit)
11525  {
11526  nativeLabel = Util.Allocate(labelByteCount + 1);
11527  }
11528  else
11529  {
11530  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11531  nativeLabel = nativeLabelStackBytes;
11532  }
11533 
11534  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11535  nativeLabel[nativeLabelOffset] = 0;
11536  }
11537  else
11538  {
11539  nativeLabel = null;
11540  }
11541 
11542  fixed (int* nativeV = &v)
11543  {
11544  byte ret = ImGuiNative.igInputInt(nativeLabel, nativeV, step, stepFast, flags);
11545  if (labelByteCount > Util.StackAllocationSizeLimit)
11546  {
11547  Util.Free(nativeLabel);
11548  }
11549 
11550  return ret != 0;
11551  }
11552  }
11553 
11560  public static bool InputInt2(string label, ref int v)
11561  {
11562  byte* nativeLabel;
11563  int labelByteCount = 0;
11564  if (label != null)
11565  {
11566  labelByteCount = Encoding.UTF8.GetByteCount(label);
11567  if (labelByteCount > Util.StackAllocationSizeLimit)
11568  {
11569  nativeLabel = Util.Allocate(labelByteCount + 1);
11570  }
11571  else
11572  {
11573  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11574  nativeLabel = nativeLabelStackBytes;
11575  }
11576 
11577  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11578  nativeLabel[nativeLabelOffset] = 0;
11579  }
11580  else
11581  {
11582  nativeLabel = null;
11583  }
11584 
11585  ImGuiInputTextFlags flags = 0;
11586  fixed (int* nativeV = &v)
11587  {
11588  byte ret = ImGuiNative.igInputInt2(nativeLabel, nativeV, flags);
11589  if (labelByteCount > Util.StackAllocationSizeLimit)
11590  {
11591  Util.Free(nativeLabel);
11592  }
11593 
11594  return ret != 0;
11595  }
11596  }
11597 
11605  public static bool InputInt2(string label, ref int v, ImGuiInputTextFlags flags)
11606  {
11607  byte* nativeLabel;
11608  int labelByteCount = 0;
11609  if (label != null)
11610  {
11611  labelByteCount = Encoding.UTF8.GetByteCount(label);
11612  if (labelByteCount > Util.StackAllocationSizeLimit)
11613  {
11614  nativeLabel = Util.Allocate(labelByteCount + 1);
11615  }
11616  else
11617  {
11618  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11619  nativeLabel = nativeLabelStackBytes;
11620  }
11621 
11622  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11623  nativeLabel[nativeLabelOffset] = 0;
11624  }
11625  else
11626  {
11627  nativeLabel = null;
11628  }
11629 
11630  fixed (int* nativeV = &v)
11631  {
11632  byte ret = ImGuiNative.igInputInt2(nativeLabel, nativeV, flags);
11633  if (labelByteCount > Util.StackAllocationSizeLimit)
11634  {
11635  Util.Free(nativeLabel);
11636  }
11637 
11638  return ret != 0;
11639  }
11640  }
11641 
11648  public static bool InputInt3(string label, ref int v)
11649  {
11650  byte* nativeLabel;
11651  int labelByteCount = 0;
11652  if (label != null)
11653  {
11654  labelByteCount = Encoding.UTF8.GetByteCount(label);
11655  if (labelByteCount > Util.StackAllocationSizeLimit)
11656  {
11657  nativeLabel = Util.Allocate(labelByteCount + 1);
11658  }
11659  else
11660  {
11661  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11662  nativeLabel = nativeLabelStackBytes;
11663  }
11664 
11665  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11666  nativeLabel[nativeLabelOffset] = 0;
11667  }
11668  else
11669  {
11670  nativeLabel = null;
11671  }
11672 
11673  ImGuiInputTextFlags flags = 0;
11674  fixed (int* nativeV = &v)
11675  {
11676  byte ret = ImGuiNative.igInputInt3(nativeLabel, nativeV, flags);
11677  if (labelByteCount > Util.StackAllocationSizeLimit)
11678  {
11679  Util.Free(nativeLabel);
11680  }
11681 
11682  return ret != 0;
11683  }
11684  }
11685 
11693  public static bool InputInt3(string label, ref int v, ImGuiInputTextFlags flags)
11694  {
11695  byte* nativeLabel;
11696  int labelByteCount = 0;
11697  if (label != null)
11698  {
11699  labelByteCount = Encoding.UTF8.GetByteCount(label);
11700  if (labelByteCount > Util.StackAllocationSizeLimit)
11701  {
11702  nativeLabel = Util.Allocate(labelByteCount + 1);
11703  }
11704  else
11705  {
11706  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11707  nativeLabel = nativeLabelStackBytes;
11708  }
11709 
11710  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11711  nativeLabel[nativeLabelOffset] = 0;
11712  }
11713  else
11714  {
11715  nativeLabel = null;
11716  }
11717 
11718  fixed (int* nativeV = &v)
11719  {
11720  byte ret = ImGuiNative.igInputInt3(nativeLabel, nativeV, flags);
11721  if (labelByteCount > Util.StackAllocationSizeLimit)
11722  {
11723  Util.Free(nativeLabel);
11724  }
11725 
11726  return ret != 0;
11727  }
11728  }
11729 
11736  public static bool InputInt4(string label, ref int v)
11737  {
11738  byte* nativeLabel;
11739  int labelByteCount = 0;
11740  if (label != null)
11741  {
11742  labelByteCount = Encoding.UTF8.GetByteCount(label);
11743  if (labelByteCount > Util.StackAllocationSizeLimit)
11744  {
11745  nativeLabel = Util.Allocate(labelByteCount + 1);
11746  }
11747  else
11748  {
11749  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11750  nativeLabel = nativeLabelStackBytes;
11751  }
11752 
11753  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11754  nativeLabel[nativeLabelOffset] = 0;
11755  }
11756  else
11757  {
11758  nativeLabel = null;
11759  }
11760 
11761  ImGuiInputTextFlags flags = 0;
11762  fixed (int* nativeV = &v)
11763  {
11764  byte ret = ImGuiNative.igInputInt4(nativeLabel, nativeV, flags);
11765  if (labelByteCount > Util.StackAllocationSizeLimit)
11766  {
11767  Util.Free(nativeLabel);
11768  }
11769 
11770  return ret != 0;
11771  }
11772  }
11773 
11781  public static bool InputInt4(string label, ref int v, ImGuiInputTextFlags flags)
11782  {
11783  byte* nativeLabel;
11784  int labelByteCount = 0;
11785  if (label != null)
11786  {
11787  labelByteCount = Encoding.UTF8.GetByteCount(label);
11788  if (labelByteCount > Util.StackAllocationSizeLimit)
11789  {
11790  nativeLabel = Util.Allocate(labelByteCount + 1);
11791  }
11792  else
11793  {
11794  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11795  nativeLabel = nativeLabelStackBytes;
11796  }
11797 
11798  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11799  nativeLabel[nativeLabelOffset] = 0;
11800  }
11801  else
11802  {
11803  nativeLabel = null;
11804  }
11805 
11806  fixed (int* nativeV = &v)
11807  {
11808  byte ret = ImGuiNative.igInputInt4(nativeLabel, nativeV, flags);
11809  if (labelByteCount > Util.StackAllocationSizeLimit)
11810  {
11811  Util.Free(nativeLabel);
11812  }
11813 
11814  return ret != 0;
11815  }
11816  }
11817 
11825  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData)
11826  {
11827  byte* nativeLabel;
11828  int labelByteCount = 0;
11829  if (label != null)
11830  {
11831  labelByteCount = Encoding.UTF8.GetByteCount(label);
11832  if (labelByteCount > Util.StackAllocationSizeLimit)
11833  {
11834  nativeLabel = Util.Allocate(labelByteCount + 1);
11835  }
11836  else
11837  {
11838  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11839  nativeLabel = nativeLabelStackBytes;
11840  }
11841 
11842  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11843  nativeLabel[nativeLabelOffset] = 0;
11844  }
11845  else
11846  {
11847  nativeLabel = null;
11848  }
11849 
11850  void* nativePData = pData.ToPointer();
11851  void* pStep = null;
11852  void* pStepFast = null;
11853  byte* nativeFormat = null;
11854  ImGuiInputTextFlags flags = 0;
11855  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, pStep, pStepFast, nativeFormat, flags);
11856  if (labelByteCount > Util.StackAllocationSizeLimit)
11857  {
11858  Util.Free(nativeLabel);
11859  }
11860 
11861  return ret != 0;
11862  }
11863 
11872  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep)
11873  {
11874  byte* nativeLabel;
11875  int labelByteCount = 0;
11876  if (label != null)
11877  {
11878  labelByteCount = Encoding.UTF8.GetByteCount(label);
11879  if (labelByteCount > Util.StackAllocationSizeLimit)
11880  {
11881  nativeLabel = Util.Allocate(labelByteCount + 1);
11882  }
11883  else
11884  {
11885  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11886  nativeLabel = nativeLabelStackBytes;
11887  }
11888 
11889  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11890  nativeLabel[nativeLabelOffset] = 0;
11891  }
11892  else
11893  {
11894  nativeLabel = null;
11895  }
11896 
11897  void* nativePData = pData.ToPointer();
11898  void* nativePStep = pStep.ToPointer();
11899  void* pStepFast = null;
11900  byte* nativeFormat = null;
11901  ImGuiInputTextFlags flags = 0;
11902  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, nativePStep, pStepFast, nativeFormat, flags);
11903  if (labelByteCount > Util.StackAllocationSizeLimit)
11904  {
11905  Util.Free(nativeLabel);
11906  }
11907 
11908  return ret != 0;
11909  }
11910 
11920  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast)
11921  {
11922  byte* nativeLabel;
11923  int labelByteCount = 0;
11924  if (label != null)
11925  {
11926  labelByteCount = Encoding.UTF8.GetByteCount(label);
11927  if (labelByteCount > Util.StackAllocationSizeLimit)
11928  {
11929  nativeLabel = Util.Allocate(labelByteCount + 1);
11930  }
11931  else
11932  {
11933  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11934  nativeLabel = nativeLabelStackBytes;
11935  }
11936 
11937  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11938  nativeLabel[nativeLabelOffset] = 0;
11939  }
11940  else
11941  {
11942  nativeLabel = null;
11943  }
11944 
11945  void* nativePData = pData.ToPointer();
11946  void* nativePStep = pStep.ToPointer();
11947  void* nativePStepFast = pStepFast.ToPointer();
11948  byte* nativeFormat = null;
11949  ImGuiInputTextFlags flags = 0;
11950  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flags);
11951  if (labelByteCount > Util.StackAllocationSizeLimit)
11952  {
11953  Util.Free(nativeLabel);
11954  }
11955 
11956  return ret != 0;
11957  }
11958 
11969  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast, string format)
11970  {
11971  byte* nativeLabel;
11972  int labelByteCount = 0;
11973  if (label != null)
11974  {
11975  labelByteCount = Encoding.UTF8.GetByteCount(label);
11976  if (labelByteCount > Util.StackAllocationSizeLimit)
11977  {
11978  nativeLabel = Util.Allocate(labelByteCount + 1);
11979  }
11980  else
11981  {
11982  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11983  nativeLabel = nativeLabelStackBytes;
11984  }
11985 
11986  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11987  nativeLabel[nativeLabelOffset] = 0;
11988  }
11989  else
11990  {
11991  nativeLabel = null;
11992  }
11993 
11994  void* nativePData = pData.ToPointer();
11995  void* nativePStep = pStep.ToPointer();
11996  void* nativePStepFast = pStepFast.ToPointer();
11997  byte* nativeFormat;
11998  int formatByteCount = 0;
11999  if (format != null)
12000  {
12001  formatByteCount = Encoding.UTF8.GetByteCount(format);
12002  if (formatByteCount > Util.StackAllocationSizeLimit)
12003  {
12004  nativeFormat = Util.Allocate(formatByteCount + 1);
12005  }
12006  else
12007  {
12008  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
12009  nativeFormat = nativeFormatStackBytes;
12010  }
12011 
12012  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
12013  nativeFormat[nativeFormatOffset] = 0;
12014  }
12015  else
12016  {
12017  nativeFormat = null;
12018  }
12019 
12020  ImGuiInputTextFlags flags = 0;
12021  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flags);
12022  if (labelByteCount > Util.StackAllocationSizeLimit)
12023  {
12024  Util.Free(nativeLabel);
12025  }
12026 
12027  if (formatByteCount > Util.StackAllocationSizeLimit)
12028  {
12029  Util.Free(nativeFormat);
12030  }
12031 
12032  return ret != 0;
12033  }
12034 
12046  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast, string format, ImGuiInputTextFlags flags)
12047  {
12048  byte* nativeLabel;
12049  int labelByteCount = 0;
12050  if (label != null)
12051  {
12052  labelByteCount = Encoding.UTF8.GetByteCount(label);
12053  if (labelByteCount > Util.StackAllocationSizeLimit)
12054  {
12055  nativeLabel = Util.Allocate(labelByteCount + 1);
12056  }
12057  else
12058  {
12059  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12060  nativeLabel = nativeLabelStackBytes;
12061  }
12062 
12063  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12064  nativeLabel[nativeLabelOffset] = 0;
12065  }
12066  else
12067  {
12068  nativeLabel = null;
12069  }
12070 
12071  void* nativePData = pData.ToPointer();
12072  void* nativePStep = pStep.ToPointer();
12073  void* nativePStepFast = pStepFast.ToPointer();
12074  byte* nativeFormat;
12075  int formatByteCount = 0;
12076  if (format != null)
12077  {
12078  formatByteCount = Encoding.UTF8.GetByteCount(format);
12079  if (formatByteCount > Util.StackAllocationSizeLimit)
12080  {
12081  nativeFormat = Util.Allocate(formatByteCount + 1);
12082  }
12083  else
12084  {
12085  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
12086  nativeFormat = nativeFormatStackBytes;
12087  }
12088 
12089  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
12090  nativeFormat[nativeFormatOffset] = 0;
12091  }
12092  else
12093  {
12094  nativeFormat = null;
12095  }
12096 
12097  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flags);
12098  if (labelByteCount > Util.StackAllocationSizeLimit)
12099  {
12100  Util.Free(nativeLabel);
12101  }
12102 
12103  if (formatByteCount > Util.StackAllocationSizeLimit)
12104  {
12105  Util.Free(nativeFormat);
12106  }
12107 
12108  return ret != 0;
12109  }
12110 
12119  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components)
12120  {
12121  byte* nativeLabel;
12122  int labelByteCount = 0;
12123  if (label != null)
12124  {
12125  labelByteCount = Encoding.UTF8.GetByteCount(label);
12126  if (labelByteCount > Util.StackAllocationSizeLimit)
12127  {
12128  nativeLabel = Util.Allocate(labelByteCount + 1);
12129  }
12130  else
12131  {
12132  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12133  nativeLabel = nativeLabelStackBytes;
12134  }
12135 
12136  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12137  nativeLabel[nativeLabelOffset] = 0;
12138  }
12139  else
12140  {
12141  nativeLabel = null;
12142  }
12143 
12144  void* nativePData = pData.ToPointer();
12145  void* pStep = null;
12146  void* pStepFast = null;
12147  byte* nativeFormat = null;
12148  ImGuiInputTextFlags flags = 0;
12149  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, pStep, pStepFast, nativeFormat, flags);
12150  if (labelByteCount > Util.StackAllocationSizeLimit)
12151  {
12152  Util.Free(nativeLabel);
12153  }
12154 
12155  return ret != 0;
12156  }
12157 
12167  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep)
12168  {
12169  byte* nativeLabel;
12170  int labelByteCount = 0;
12171  if (label != null)
12172  {
12173  labelByteCount = Encoding.UTF8.GetByteCount(label);
12174  if (labelByteCount > Util.StackAllocationSizeLimit)
12175  {
12176  nativeLabel = Util.Allocate(labelByteCount + 1);
12177  }
12178  else
12179  {
12180  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12181  nativeLabel = nativeLabelStackBytes;
12182  }
12183 
12184  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12185  nativeLabel[nativeLabelOffset] = 0;
12186  }
12187  else
12188  {
12189  nativeLabel = null;
12190  }
12191 
12192  void* nativePData = pData.ToPointer();
12193  void* nativePStep = pStep.ToPointer();
12194  void* pStepFast = null;
12195  byte* nativeFormat = null;
12196  ImGuiInputTextFlags flags = 0;
12197  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, pStepFast, nativeFormat, flags);
12198  if (labelByteCount > Util.StackAllocationSizeLimit)
12199  {
12200  Util.Free(nativeLabel);
12201  }
12202 
12203  return ret != 0;
12204  }
12205 
12216  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast)
12217  {
12218  byte* nativeLabel;
12219  int labelByteCount = 0;
12220  if (label != null)
12221  {
12222  labelByteCount = Encoding.UTF8.GetByteCount(label);
12223  if (labelByteCount > Util.StackAllocationSizeLimit)
12224  {
12225  nativeLabel = Util.Allocate(labelByteCount + 1);
12226  }
12227  else
12228  {
12229  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12230  nativeLabel = nativeLabelStackBytes;
12231  }
12232 
12233  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12234  nativeLabel[nativeLabelOffset] = 0;
12235  }
12236  else
12237  {
12238  nativeLabel = null;
12239  }
12240 
12241  void* nativePData = pData.ToPointer();
12242  void* nativePStep = pStep.ToPointer();
12243  void* nativePStepFast = pStepFast.ToPointer();
12244  byte* nativeFormat = null;
12245  ImGuiInputTextFlags flags = 0;
12246  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flags);
12247  if (labelByteCount > Util.StackAllocationSizeLimit)
12248  {
12249  Util.Free(nativeLabel);
12250  }
12251 
12252  return ret != 0;
12253  }
12254 
12266  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast, string format)
12267  {
12268  byte* nativeLabel;
12269  int labelByteCount = 0;
12270  if (label != null)
12271  {
12272  labelByteCount = Encoding.UTF8.GetByteCount(label);
12273  if (labelByteCount > Util.StackAllocationSizeLimit)
12274  {
12275  nativeLabel = Util.Allocate(labelByteCount + 1);
12276  }
12277  else
12278  {
12279  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12280  nativeLabel = nativeLabelStackBytes;
12281  }
12282 
12283  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12284  nativeLabel[nativeLabelOffset] = 0;
12285  }
12286  else
12287  {
12288  nativeLabel = null;
12289  }
12290 
12291  void* nativePData = pData.ToPointer();
12292  void* nativePStep = pStep.ToPointer();
12293  void* nativePStepFast = pStepFast.ToPointer();
12294  byte* nativeFormat;
12295  int formatByteCount = 0;
12296  if (format != null)
12297  {
12298  formatByteCount = Encoding.UTF8.GetByteCount(format);
12299  if (formatByteCount > Util.StackAllocationSizeLimit)
12300  {
12301  nativeFormat = Util.Allocate(formatByteCount + 1);
12302  }
12303  else
12304  {
12305  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
12306  nativeFormat = nativeFormatStackBytes;
12307  }
12308 
12309  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
12310  nativeFormat[nativeFormatOffset] = 0;
12311  }
12312  else
12313  {
12314  nativeFormat = null;
12315  }
12316 
12317  ImGuiInputTextFlags flags = 0;
12318  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flags);
12319  if (labelByteCount > Util.StackAllocationSizeLimit)
12320  {
12321  Util.Free(nativeLabel);
12322  }
12323 
12324  if (formatByteCount > Util.StackAllocationSizeLimit)
12325  {
12326  Util.Free(nativeFormat);
12327  }
12328 
12329  return ret != 0;
12330  }
12331 
12344  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast, string format, ImGuiInputTextFlags flags)
12345  {
12346  byte* nativeLabel;
12347  int labelByteCount = 0;
12348  if (label != null)
12349  {
12350  labelByteCount = Encoding.UTF8.GetByteCount(label);
12351  if (labelByteCount > Util.StackAllocationSizeLimit)
12352  {
12353  nativeLabel = Util.Allocate(labelByteCount + 1);
12354  }
12355  else
12356  {
12357  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12358  nativeLabel = nativeLabelStackBytes;
12359  }
12360 
12361  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12362  nativeLabel[nativeLabelOffset] = 0;
12363  }
12364  else
12365  {
12366  nativeLabel = null;
12367  }
12368 
12369  void* nativePData = pData.ToPointer();
12370  void* nativePStep = pStep.ToPointer();
12371  void* nativePStepFast = pStepFast.ToPointer();
12372  byte* nativeFormat;
12373  int formatByteCount = 0;
12374  if (format != null)
12375  {
12376  formatByteCount = Encoding.UTF8.GetByteCount(format);
12377  if (formatByteCount > Util.StackAllocationSizeLimit)
12378  {
12379  nativeFormat = Util.Allocate(formatByteCount + 1);
12380  }
12381  else
12382  {
12383  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
12384  nativeFormat = nativeFormatStackBytes;
12385  }
12386 
12387  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
12388  nativeFormat[nativeFormatOffset] = 0;
12389  }
12390  else
12391  {
12392  nativeFormat = null;
12393  }
12394 
12395  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flags);
12396  if (labelByteCount > Util.StackAllocationSizeLimit)
12397  {
12398  Util.Free(nativeLabel);
12399  }
12400 
12401  if (formatByteCount > Util.StackAllocationSizeLimit)
12402  {
12403  Util.Free(nativeFormat);
12404  }
12405 
12406  return ret != 0;
12407  }
12408 
12415  public static bool InvisibleButton(string strId, Vector2F size)
12416  {
12417  byte* nativeStrId;
12418  int strIdByteCount = 0;
12419  if (strId != null)
12420  {
12421  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12422  if (strIdByteCount > Util.StackAllocationSizeLimit)
12423  {
12424  nativeStrId = Util.Allocate(strIdByteCount + 1);
12425  }
12426  else
12427  {
12428  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
12429  nativeStrId = nativeStrIdStackBytes;
12430  }
12431 
12432  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
12433  nativeStrId[nativeStrIdOffset] = 0;
12434  }
12435  else
12436  {
12437  nativeStrId = null;
12438  }
12439 
12440  ImGuiButtonFlags flags = 0;
12441  byte ret = ImGuiNative.igInvisibleButton(nativeStrId, size, flags);
12442  if (strIdByteCount > Util.StackAllocationSizeLimit)
12443  {
12444  Util.Free(nativeStrId);
12445  }
12446 
12447  return ret != 0;
12448  }
12449 
12457  public static bool InvisibleButton(string strId, Vector2F size, ImGuiButtonFlags flags)
12458  {
12459  byte* nativeStrId;
12460  int strIdByteCount = 0;
12461  if (strId != null)
12462  {
12463  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12464  if (strIdByteCount > Util.StackAllocationSizeLimit)
12465  {
12466  nativeStrId = Util.Allocate(strIdByteCount + 1);
12467  }
12468  else
12469  {
12470  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
12471  nativeStrId = nativeStrIdStackBytes;
12472  }
12473 
12474  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
12475  nativeStrId[nativeStrIdOffset] = 0;
12476  }
12477  else
12478  {
12479  nativeStrId = null;
12480  }
12481 
12482  byte ret = ImGuiNative.igInvisibleButton(nativeStrId, size, flags);
12483  if (strIdByteCount > Util.StackAllocationSizeLimit)
12484  {
12485  Util.Free(nativeStrId);
12486  }
12487 
12488  return ret != 0;
12489  }
12490 
12495  public static bool IsAnyItemActive()
12496  {
12497  byte ret = ImGuiNative.igIsAnyItemActive();
12498  return ret != 0;
12499  }
12500 
12505  public static bool IsAnyItemFocused()
12506  {
12507  byte ret = ImGuiNative.igIsAnyItemFocused();
12508  return ret != 0;
12509  }
12510 
12515  public static bool IsAnyItemHovered()
12516  {
12517  byte ret = ImGuiNative.igIsAnyItemHovered();
12518  return ret != 0;
12519  }
12520 
12525  public static bool IsAnyMouseDown()
12526  {
12527  byte ret = ImGuiNative.igIsAnyMouseDown();
12528  return ret != 0;
12529  }
12530 
12535  public static bool IsItemActivated()
12536  {
12537  byte ret = ImGuiNative.igIsItemActivated();
12538  return ret != 0;
12539  }
12540 
12545  public static bool IsItemActive()
12546  {
12547  byte ret = ImGuiNative.igIsItemActive();
12548  return ret != 0;
12549  }
12550 
12555  public static bool IsItemClicked()
12556  {
12557  ImGuiMouseButton mouseButton = 0;
12558  byte ret = ImGuiNative.igIsItemClicked(mouseButton);
12559  return ret != 0;
12560  }
12561 
12567  public static bool IsItemClicked(ImGuiMouseButton mouseButton)
12568  {
12569  byte ret = ImGuiNative.igIsItemClicked(mouseButton);
12570  return ret != 0;
12571  }
12572 
12577  public static bool IsItemDeactivated()
12578  {
12579  byte ret = ImGuiNative.igIsItemDeactivated();
12580  return ret != 0;
12581  }
12582 
12587  public static bool IsItemDeactivatedAfterEdit()
12588  {
12589  byte ret = ImGuiNative.igIsItemDeactivatedAfterEdit();
12590  return ret != 0;
12591  }
12592 
12597  public static bool IsItemEdited()
12598  {
12599  byte ret = ImGuiNative.igIsItemEdited();
12600  return ret != 0;
12601  }
12602 
12607  public static bool IsItemFocused()
12608  {
12609  byte ret = ImGuiNative.igIsItemFocused();
12610  return ret != 0;
12611  }
12612 
12617  public static bool IsItemHovered()
12618  {
12619  ImGuiHoveredFlags flags = 0;
12620  byte ret = ImGuiNative.igIsItemHovered(flags);
12621  return ret != 0;
12622  }
12623 
12629  public static bool IsItemHovered(ImGuiHoveredFlags flags)
12630  {
12631  byte ret = ImGuiNative.igIsItemHovered(flags);
12632  return ret != 0;
12633  }
12634 
12639  public static bool IsItemToggledOpen()
12640  {
12641  byte ret = ImGuiNative.igIsItemToggledOpen();
12642  return ret != 0;
12643  }
12644 
12649  public static bool IsItemVisible()
12650  {
12651  byte ret = ImGuiNative.igIsItemVisible();
12652  return ret != 0;
12653  }
12654 
12660  public static bool IsKeyDown(ImGuiKey key)
12661  {
12662  byte ret = ImGuiNative.igIsKeyDown_Nil(key);
12663  return ret != 0;
12664  }
12665 
12671  public static bool IsKeyPressed(ImGuiKey key)
12672  {
12673  byte repeat = 1;
12674  byte ret = ImGuiNative.igIsKeyPressed_Bool(key, repeat);
12675  return ret != 0;
12676  }
12677 
12684  public static bool IsKeyPressed(ImGuiKey key, bool repeat)
12685  {
12686  byte nativeRepeat = repeat ? (byte) 1 : (byte) 0;
12687  byte ret = ImGuiNative.igIsKeyPressed_Bool(key, nativeRepeat);
12688  return ret != 0;
12689  }
12690 
12696  public static bool IsKeyReleased(ImGuiKey key)
12697  {
12698  byte ret = ImGuiNative.igIsKeyReleased_Nil(key);
12699  return ret != 0;
12700  }
12701 
12707  public static bool IsMouseClicked(ImGuiMouseButton button)
12708  {
12709  byte repeat = 0;
12710  byte ret = ImGuiNative.igIsMouseClicked_Bool(button, repeat);
12711  return ret != 0;
12712  }
12713 
12720  public static bool IsMouseClicked(ImGuiMouseButton button, bool repeat)
12721  {
12722  byte nativeRepeat = repeat ? (byte) 1 : (byte) 0;
12723  byte ret = ImGuiNative.igIsMouseClicked_Bool(button, nativeRepeat);
12724  return ret != 0;
12725  }
12726 
12732  public static bool IsMouseDoubleClicked(ImGuiMouseButton button)
12733  {
12734  byte ret = ImGuiNative.igIsMouseDoubleClicked(button);
12735  return ret != 0;
12736  }
12737 
12743  public static bool IsMouseDown(ImGuiMouseButton button)
12744  {
12745  byte ret = ImGuiNative.igIsMouseDown_Nil(button);
12746  return ret != 0;
12747  }
12748 
12754  public static bool IsMouseDragging(ImGuiMouseButton button)
12755  {
12756  float lockThreshold = -1.0f;
12757  byte ret = ImGuiNative.igIsMouseDragging(button, lockThreshold);
12758  return ret != 0;
12759  }
12760 
12767  public static bool IsMouseDragging(ImGuiMouseButton button, float lockThreshold)
12768  {
12769  byte ret = ImGuiNative.igIsMouseDragging(button, lockThreshold);
12770  return ret != 0;
12771  }
12772 
12779  public static bool IsMouseHoveringRect(Vector2F rMin, Vector2F rMax)
12780  {
12781  byte clip = 1;
12782  byte ret = ImGuiNative.igIsMouseHoveringRect(rMin, rMax, clip);
12783  return ret != 0;
12784  }
12785 
12793  public static bool IsMouseHoveringRect(Vector2F rMin, Vector2F rMax, bool clip)
12794  {
12795  byte nativeClip = clip ? (byte) 1 : (byte) 0;
12796  byte ret = ImGuiNative.igIsMouseHoveringRect(rMin, rMax, nativeClip);
12797  return ret != 0;
12798  }
12799 
12804  public static bool IsMousePosValid()
12805  {
12806  Vector2F* mousePos = null;
12807  byte ret = ImGuiNative.igIsMousePosValid(mousePos);
12808  return ret != 0;
12809  }
12810 
12816  public static bool IsMousePosValid(ref Vector2F mousePos)
12817  {
12818  fixed (Vector2F* nativeMousePos = &mousePos)
12819  {
12820  byte ret = ImGuiNative.igIsMousePosValid(nativeMousePos);
12821  return ret != 0;
12822  }
12823  }
12824 
12830  public static bool IsMouseReleased(ImGuiMouseButton button)
12831  {
12832  byte ret = ImGuiNative.igIsMouseReleased_Nil(button);
12833  return ret != 0;
12834  }
12835 
12841  public static bool IsPopupOpen(string strId)
12842  {
12843  byte* nativeStrId;
12844  int strIdByteCount = 0;
12845  if (strId != null)
12846  {
12847  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12848  if (strIdByteCount > Util.StackAllocationSizeLimit)
12849  {
12850  nativeStrId = Util.Allocate(strIdByteCount + 1);
12851  }
12852  else
12853  {
12854  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
12855  nativeStrId = nativeStrIdStackBytes;
12856  }
12857 
12858  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
12859  nativeStrId[nativeStrIdOffset] = 0;
12860  }
12861  else
12862  {
12863  nativeStrId = null;
12864  }
12865 
12866  ImGuiPopupFlags flags = 0;
12867  byte ret = ImGuiNative.igIsPopupOpen_Str(nativeStrId, flags);
12868  if (strIdByteCount > Util.StackAllocationSizeLimit)
12869  {
12870  Util.Free(nativeStrId);
12871  }
12872 
12873  return ret != 0;
12874  }
12875 
12882  public static bool IsPopupOpen(string strId, ImGuiPopupFlags flags)
12883  {
12884  byte* nativeStrId;
12885  int strIdByteCount = 0;
12886  if (strId != null)
12887  {
12888  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12889  if (strIdByteCount > Util.StackAllocationSizeLimit)
12890  {
12891  nativeStrId = Util.Allocate(strIdByteCount + 1);
12892  }
12893  else
12894  {
12895  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
12896  nativeStrId = nativeStrIdStackBytes;
12897  }
12898 
12899  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
12900  nativeStrId[nativeStrIdOffset] = 0;
12901  }
12902  else
12903  {
12904  nativeStrId = null;
12905  }
12906 
12907  byte ret = ImGuiNative.igIsPopupOpen_Str(nativeStrId, flags);
12908  if (strIdByteCount > Util.StackAllocationSizeLimit)
12909  {
12910  Util.Free(nativeStrId);
12911  }
12912 
12913  return ret != 0;
12914  }
12915 
12921  public static bool IsRectVisible(Vector2F size)
12922  {
12923  byte ret = ImGuiNative.igIsRectVisible_Nil(size);
12924  return ret != 0;
12925  }
12926 
12933  public static bool IsRectVisible(Vector2F rectMin, Vector2F rectMax)
12934  {
12935  byte ret = ImGuiNative.igIsRectVisible_Vec2(rectMin, rectMax);
12936  return ret != 0;
12937  }
12938 
12943  public static bool IsWindowAppearing()
12944  {
12945  byte ret = ImGuiNative.igIsWindowAppearing();
12946  return ret != 0;
12947  }
12948 
12953  public static bool IsWindowCollapsed()
12954  {
12955  byte ret = ImGuiNative.igIsWindowCollapsed();
12956  return ret != 0;
12957  }
12958 
12963  public static bool IsWindowDocked()
12964  {
12965  byte ret = ImGuiNative.igIsWindowDocked();
12966  return ret != 0;
12967  }
12968 
12973  public static bool IsWindowFocused()
12974  {
12975  ImGuiFocusedFlags flags = 0;
12976  byte ret = ImGuiNative.igIsWindowFocused(flags);
12977  return ret != 0;
12978  }
12979 
12985  public static bool IsWindowFocused(ImGuiFocusedFlags flags)
12986  {
12987  byte ret = ImGuiNative.igIsWindowFocused(flags);
12988  return ret != 0;
12989  }
12990 
12995  public static bool IsWindowHovered()
12996  {
12997  ImGuiHoveredFlags flags = 0;
12998  byte ret = ImGuiNative.igIsWindowHovered(flags);
12999  return ret != 0;
13000  }
13001 
13007  public static bool IsWindowHovered(ImGuiHoveredFlags flags)
13008  {
13009  byte ret = ImGuiNative.igIsWindowHovered(flags);
13010  return ret != 0;
13011  }
13012 
13018  public static void LabelText(string label, string fmt)
13019  {
13020  byte* nativeLabel;
13021  int labelByteCount = 0;
13022  if (label != null)
13023  {
13024  labelByteCount = Encoding.UTF8.GetByteCount(label);
13025  if (labelByteCount > Util.StackAllocationSizeLimit)
13026  {
13027  nativeLabel = Util.Allocate(labelByteCount + 1);
13028  }
13029  else
13030  {
13031  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13032  nativeLabel = nativeLabelStackBytes;
13033  }
13034 
13035  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13036  nativeLabel[nativeLabelOffset] = 0;
13037  }
13038  else
13039  {
13040  nativeLabel = null;
13041  }
13042 
13043  byte* nativeFmt;
13044  int fmtByteCount = 0;
13045  if (fmt != null)
13046  {
13047  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
13048  if (fmtByteCount > Util.StackAllocationSizeLimit)
13049  {
13050  nativeFmt = Util.Allocate(fmtByteCount + 1);
13051  }
13052  else
13053  {
13054  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
13055  nativeFmt = nativeFmtStackBytes;
13056  }
13057 
13058  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
13059  nativeFmt[nativeFmtOffset] = 0;
13060  }
13061  else
13062  {
13063  nativeFmt = null;
13064  }
13065 
13066  ImGuiNative.igLabelText(nativeLabel, nativeFmt);
13067  if (labelByteCount > Util.StackAllocationSizeLimit)
13068  {
13069  Util.Free(nativeLabel);
13070  }
13071 
13072  if (fmtByteCount > Util.StackAllocationSizeLimit)
13073  {
13074  Util.Free(nativeFmt);
13075  }
13076  }
13077 
13086  public static bool ListBox(string label, ref int currentItem, string[] items, int itemsCount)
13087  {
13088  byte* nativeLabel;
13089  int labelByteCount = 0;
13090  if (label != null)
13091  {
13092  labelByteCount = Encoding.UTF8.GetByteCount(label);
13093  if (labelByteCount > Util.StackAllocationSizeLimit)
13094  {
13095  nativeLabel = Util.Allocate(labelByteCount + 1);
13096  }
13097  else
13098  {
13099  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13100  nativeLabel = nativeLabelStackBytes;
13101  }
13102 
13103  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13104  nativeLabel[nativeLabelOffset] = 0;
13105  }
13106  else
13107  {
13108  nativeLabel = null;
13109  }
13110 
13111  int* itemsByteCounts = stackalloc int[items.Length];
13112  int itemsByteCount = 0;
13113  for (int i = 0; i < items.Length; i++)
13114  {
13115  string s = items[i];
13116  itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
13117  itemsByteCount += itemsByteCounts[i] + 1;
13118  }
13119 
13120  byte* nativeItemsData = stackalloc byte[itemsByteCount];
13121  int offset = 0;
13122  for (int i = 0; i < items.Length; i++)
13123  {
13124  string s = items[i];
13125  fixed (char* sPtr = s)
13126  {
13127  offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
13128  nativeItemsData[offset] = 0;
13129  offset += 1;
13130  }
13131  }
13132 
13133  byte** nativeItems = stackalloc byte*[items.Length];
13134  offset = 0;
13135  for (int i = 0; i < items.Length; i++)
13136  {
13137  nativeItems[i] = &nativeItemsData[offset];
13138  offset += itemsByteCounts[i] + 1;
13139  }
13140 
13141  int heightInItems = -1;
13142  fixed (int* nativeCurrentItem = &currentItem)
13143  {
13144  byte ret = ImGuiNative.igListBox_Str_arr(nativeLabel, nativeCurrentItem, nativeItems, itemsCount, heightInItems);
13145  if (labelByteCount > Util.StackAllocationSizeLimit)
13146  {
13147  Util.Free(nativeLabel);
13148  }
13149 
13150  return ret != 0;
13151  }
13152  }
13153 
13163  public static bool ListBox(string label, ref int currentItem, string[] items, int itemsCount, int heightInItems)
13164  {
13165  byte* nativeLabel;
13166  int labelByteCount = 0;
13167  if (label != null)
13168  {
13169  labelByteCount = Encoding.UTF8.GetByteCount(label);
13170  if (labelByteCount > Util.StackAllocationSizeLimit)
13171  {
13172  nativeLabel = Util.Allocate(labelByteCount + 1);
13173  }
13174  else
13175  {
13176  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13177  nativeLabel = nativeLabelStackBytes;
13178  }
13179 
13180  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13181  nativeLabel[nativeLabelOffset] = 0;
13182  }
13183  else
13184  {
13185  nativeLabel = null;
13186  }
13187 
13188  int* itemsByteCounts = stackalloc int[items.Length];
13189  int itemsByteCount = 0;
13190  for (int i = 0; i < items.Length; i++)
13191  {
13192  string s = items[i];
13193  itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
13194  itemsByteCount += itemsByteCounts[i] + 1;
13195  }
13196 
13197  byte* nativeItemsData = stackalloc byte[itemsByteCount];
13198  int offset = 0;
13199  for (int i = 0; i < items.Length; i++)
13200  {
13201  string s = items[i];
13202  fixed (char* sPtr = s)
13203  {
13204  offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
13205  nativeItemsData[offset] = 0;
13206  offset += 1;
13207  }
13208  }
13209 
13210  byte** nativeItems = stackalloc byte*[items.Length];
13211  offset = 0;
13212  for (int i = 0; i < items.Length; i++)
13213  {
13214  nativeItems[i] = &nativeItemsData[offset];
13215  offset += itemsByteCounts[i] + 1;
13216  }
13217 
13218  fixed (int* nativeCurrentItem = &currentItem)
13219  {
13220  byte ret = ImGuiNative.igListBox_Str_arr(nativeLabel, nativeCurrentItem, nativeItems, itemsCount, heightInItems);
13221  if (labelByteCount > Util.StackAllocationSizeLimit)
13222  {
13223  Util.Free(nativeLabel);
13224  }
13225 
13226  return ret != 0;
13227  }
13228  }
13229 
13234  public static void LoadIniSettingsFromDisk(string iniFilename)
13235  {
13236  byte* nativeIniFilename;
13237  int iniFilenameByteCount = 0;
13238  if (iniFilename != null)
13239  {
13240  iniFilenameByteCount = Encoding.UTF8.GetByteCount(iniFilename);
13241  if (iniFilenameByteCount > Util.StackAllocationSizeLimit)
13242  {
13243  nativeIniFilename = Util.Allocate(iniFilenameByteCount + 1);
13244  }
13245  else
13246  {
13247  byte* nativeIniFilenameStackBytes = stackalloc byte[iniFilenameByteCount + 1];
13248  nativeIniFilename = nativeIniFilenameStackBytes;
13249  }
13250 
13251  int nativeIniFilenameOffset = Util.GetUtf8(iniFilename, nativeIniFilename, iniFilenameByteCount);
13252  nativeIniFilename[nativeIniFilenameOffset] = 0;
13253  }
13254  else
13255  {
13256  nativeIniFilename = null;
13257  }
13258 
13259  ImGuiNative.igLoadIniSettingsFromDisk(nativeIniFilename);
13260  if (iniFilenameByteCount > Util.StackAllocationSizeLimit)
13261  {
13262  Util.Free(nativeIniFilename);
13263  }
13264  }
13265 
13270  public static void LoadIniSettingsFromMemory(string iniData)
13271  {
13272  byte* nativeIniData;
13273  int iniDataByteCount = 0;
13274  if (iniData != null)
13275  {
13276  iniDataByteCount = Encoding.UTF8.GetByteCount(iniData);
13277  if (iniDataByteCount > Util.StackAllocationSizeLimit)
13278  {
13279  nativeIniData = Util.Allocate(iniDataByteCount + 1);
13280  }
13281  else
13282  {
13283  byte* nativeIniDataStackBytes = stackalloc byte[iniDataByteCount + 1];
13284  nativeIniData = nativeIniDataStackBytes;
13285  }
13286 
13287  int nativeIniDataOffset = Util.GetUtf8(iniData, nativeIniData, iniDataByteCount);
13288  nativeIniData[nativeIniDataOffset] = 0;
13289  }
13290  else
13291  {
13292  nativeIniData = null;
13293  }
13294 
13295  uint iniSize = 0;
13296  ImGuiNative.igLoadIniSettingsFromMemory(nativeIniData, iniSize);
13297  if (iniDataByteCount > Util.StackAllocationSizeLimit)
13298  {
13299  Util.Free(nativeIniData);
13300  }
13301  }
13302 
13308  public static void LoadIniSettingsFromMemory(string iniData, uint iniSize)
13309  {
13310  byte* nativeIniData;
13311  int iniDataByteCount = 0;
13312  if (iniData != null)
13313  {
13314  iniDataByteCount = Encoding.UTF8.GetByteCount(iniData);
13315  if (iniDataByteCount > Util.StackAllocationSizeLimit)
13316  {
13317  nativeIniData = Util.Allocate(iniDataByteCount + 1);
13318  }
13319  else
13320  {
13321  byte* nativeIniDataStackBytes = stackalloc byte[iniDataByteCount + 1];
13322  nativeIniData = nativeIniDataStackBytes;
13323  }
13324 
13325  int nativeIniDataOffset = Util.GetUtf8(iniData, nativeIniData, iniDataByteCount);
13326  nativeIniData[nativeIniDataOffset] = 0;
13327  }
13328  else
13329  {
13330  nativeIniData = null;
13331  }
13332 
13333  ImGuiNative.igLoadIniSettingsFromMemory(nativeIniData, iniSize);
13334  if (iniDataByteCount > Util.StackAllocationSizeLimit)
13335  {
13336  Util.Free(nativeIniData);
13337  }
13338  }
13339 
13343  public static void LogButtons()
13344  {
13345  ImGuiNative.igLogButtons();
13346  }
13347 
13351  public static void LogFinish()
13352  {
13353  ImGuiNative.igLogFinish();
13354  }
13355 
13360  public static void LogText(string fmt)
13361  {
13362  byte* nativeFmt;
13363  int fmtByteCount = 0;
13364  if (fmt != null)
13365  {
13366  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
13367  if (fmtByteCount > Util.StackAllocationSizeLimit)
13368  {
13369  nativeFmt = Util.Allocate(fmtByteCount + 1);
13370  }
13371  else
13372  {
13373  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
13374  nativeFmt = nativeFmtStackBytes;
13375  }
13376 
13377  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
13378  nativeFmt[nativeFmtOffset] = 0;
13379  }
13380  else
13381  {
13382  nativeFmt = null;
13383  }
13384 
13385  ImGuiNative.igLogText(nativeFmt);
13386  if (fmtByteCount > Util.StackAllocationSizeLimit)
13387  {
13388  Util.Free(nativeFmt);
13389  }
13390  }
13391 
13395  public static void LogToClipboard()
13396  {
13397  int autoOpenDepth = -1;
13398  ImGuiNative.igLogToClipboard(autoOpenDepth);
13399  }
13400 
13405  public static void LogToClipboard(int autoOpenDepth)
13406  {
13407  ImGuiNative.igLogToClipboard(autoOpenDepth);
13408  }
13409 
13413  public static void LogToFile()
13414  {
13415  int autoOpenDepth = -1;
13416  byte* nativeFilename = null;
13417  ImGuiNative.igLogToFile(autoOpenDepth, nativeFilename);
13418  }
13419 
13424  public static void LogToFile(int autoOpenDepth)
13425  {
13426  byte* nativeFilename = null;
13427  ImGuiNative.igLogToFile(autoOpenDepth, nativeFilename);
13428  }
13429 
13435  public static void LogToFile(int autoOpenDepth, string filename)
13436  {
13437  byte* nativeFilename;
13438  int filenameByteCount = 0;
13439  if (filename != null)
13440  {
13441  filenameByteCount = Encoding.UTF8.GetByteCount(filename);
13442  if (filenameByteCount > Util.StackAllocationSizeLimit)
13443  {
13444  nativeFilename = Util.Allocate(filenameByteCount + 1);
13445  }
13446  else
13447  {
13448  byte* nativeFilenameStackBytes = stackalloc byte[filenameByteCount + 1];
13449  nativeFilename = nativeFilenameStackBytes;
13450  }
13451 
13452  int nativeFilenameOffset = Util.GetUtf8(filename, nativeFilename, filenameByteCount);
13453  nativeFilename[nativeFilenameOffset] = 0;
13454  }
13455  else
13456  {
13457  nativeFilename = null;
13458  }
13459 
13460  ImGuiNative.igLogToFile(autoOpenDepth, nativeFilename);
13461  if (filenameByteCount > Util.StackAllocationSizeLimit)
13462  {
13463  Util.Free(nativeFilename);
13464  }
13465  }
13466 
13470  public static void LogToTty()
13471  {
13472  int autoOpenDepth = -1;
13473  ImGuiNative.igLogToTTY(autoOpenDepth);
13474  }
13475 
13480  public static void LogToTty(int autoOpenDepth)
13481  {
13482  ImGuiNative.igLogToTTY(autoOpenDepth);
13483  }
13484 
13490  public static IntPtr MemAlloc(uint size)
13491  {
13492  void* ret = ImGuiNative.igMemAlloc(size);
13493  return (IntPtr) ret;
13494  }
13495 
13500  public static void MemFree(IntPtr ptr)
13501  {
13502  void* nativePtr = ptr.ToPointer();
13503  ImGuiNative.igMemFree(nativePtr);
13504  }
13505 
13511  public static bool MenuItem(string label)
13512  {
13513  byte* nativeLabel;
13514  int labelByteCount = 0;
13515  if (label != null)
13516  {
13517  labelByteCount = Encoding.UTF8.GetByteCount(label);
13518  if (labelByteCount > Util.StackAllocationSizeLimit)
13519  {
13520  nativeLabel = Util.Allocate(labelByteCount + 1);
13521  }
13522  else
13523  {
13524  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13525  nativeLabel = nativeLabelStackBytes;
13526  }
13527 
13528  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13529  nativeLabel[nativeLabelOffset] = 0;
13530  }
13531  else
13532  {
13533  nativeLabel = null;
13534  }
13535 
13536  byte* nativeShortcut = null;
13537  byte selected = 0;
13538  byte enabled = 1;
13539  byte ret = ImGuiNative.igMenuItem_Bool(nativeLabel, nativeShortcut, selected, enabled);
13540  if (labelByteCount > Util.StackAllocationSizeLimit)
13541  {
13542  Util.Free(nativeLabel);
13543  }
13544 
13545  return ret != 0;
13546  }
13547 
13554  public static bool MenuItem(string label, string shortcut)
13555  {
13556  byte* nativeLabel;
13557  int labelByteCount = 0;
13558  if (label != null)
13559  {
13560  labelByteCount = Encoding.UTF8.GetByteCount(label);
13561  if (labelByteCount > Util.StackAllocationSizeLimit)
13562  {
13563  nativeLabel = Util.Allocate(labelByteCount + 1);
13564  }
13565  else
13566  {
13567  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13568  nativeLabel = nativeLabelStackBytes;
13569  }
13570 
13571  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13572  nativeLabel[nativeLabelOffset] = 0;
13573  }
13574  else
13575  {
13576  nativeLabel = null;
13577  }
13578 
13579  byte* nativeShortcut;
13580  int shortcutByteCount = 0;
13581  if (shortcut != null)
13582  {
13583  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13584  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13585  {
13586  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13587  }
13588  else
13589  {
13590  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13591  nativeShortcut = nativeShortcutStackBytes;
13592  }
13593 
13594  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13595  nativeShortcut[nativeShortcutOffset] = 0;
13596  }
13597  else
13598  {
13599  nativeShortcut = null;
13600  }
13601 
13602  byte selected = 0;
13603  byte enabled = 1;
13604  byte ret = ImGuiNative.igMenuItem_Bool(nativeLabel, nativeShortcut, selected, enabled);
13605  if (labelByteCount > Util.StackAllocationSizeLimit)
13606  {
13607  Util.Free(nativeLabel);
13608  }
13609 
13610  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13611  {
13612  Util.Free(nativeShortcut);
13613  }
13614 
13615  return ret != 0;
13616  }
13617 
13625  public static bool MenuItem(string label, string shortcut, bool selected)
13626  {
13627  byte* nativeLabel;
13628  int labelByteCount = 0;
13629  if (label != null)
13630  {
13631  labelByteCount = Encoding.UTF8.GetByteCount(label);
13632  if (labelByteCount > Util.StackAllocationSizeLimit)
13633  {
13634  nativeLabel = Util.Allocate(labelByteCount + 1);
13635  }
13636  else
13637  {
13638  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13639  nativeLabel = nativeLabelStackBytes;
13640  }
13641 
13642  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13643  nativeLabel[nativeLabelOffset] = 0;
13644  }
13645  else
13646  {
13647  nativeLabel = null;
13648  }
13649 
13650  byte* nativeShortcut;
13651  int shortcutByteCount = 0;
13652  if (shortcut != null)
13653  {
13654  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13655  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13656  {
13657  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13658  }
13659  else
13660  {
13661  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13662  nativeShortcut = nativeShortcutStackBytes;
13663  }
13664 
13665  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13666  nativeShortcut[nativeShortcutOffset] = 0;
13667  }
13668  else
13669  {
13670  nativeShortcut = null;
13671  }
13672 
13673  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
13674  byte enabled = 1;
13675  byte ret = ImGuiNative.igMenuItem_Bool(nativeLabel, nativeShortcut, nativeSelected, enabled);
13676  if (labelByteCount > Util.StackAllocationSizeLimit)
13677  {
13678  Util.Free(nativeLabel);
13679  }
13680 
13681  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13682  {
13683  Util.Free(nativeShortcut);
13684  }
13685 
13686  return ret != 0;
13687  }
13688 
13697  public static bool MenuItem(string label, string shortcut, bool selected, bool enabled)
13698  {
13699  byte* nativeLabel;
13700  int labelByteCount = 0;
13701  if (label != null)
13702  {
13703  labelByteCount = Encoding.UTF8.GetByteCount(label);
13704  if (labelByteCount > Util.StackAllocationSizeLimit)
13705  {
13706  nativeLabel = Util.Allocate(labelByteCount + 1);
13707  }
13708  else
13709  {
13710  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13711  nativeLabel = nativeLabelStackBytes;
13712  }
13713 
13714  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13715  nativeLabel[nativeLabelOffset] = 0;
13716  }
13717  else
13718  {
13719  nativeLabel = null;
13720  }
13721 
13722  byte* nativeShortcut;
13723  int shortcutByteCount = 0;
13724  if (shortcut != null)
13725  {
13726  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13727  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13728  {
13729  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13730  }
13731  else
13732  {
13733  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13734  nativeShortcut = nativeShortcutStackBytes;
13735  }
13736 
13737  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13738  nativeShortcut[nativeShortcutOffset] = 0;
13739  }
13740  else
13741  {
13742  nativeShortcut = null;
13743  }
13744 
13745  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
13746  byte nativeEnabled = enabled ? (byte) 1 : (byte) 0;
13747  byte ret = ImGuiNative.igMenuItem_Bool(nativeLabel, nativeShortcut, nativeSelected, nativeEnabled);
13748  if (labelByteCount > Util.StackAllocationSizeLimit)
13749  {
13750  Util.Free(nativeLabel);
13751  }
13752 
13753  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13754  {
13755  Util.Free(nativeShortcut);
13756  }
13757 
13758  return ret != 0;
13759  }
13760 
13768  public static bool MenuItem(string label, string shortcut, ref bool pSelected)
13769  {
13770  byte* nativeLabel;
13771  int labelByteCount = 0;
13772  if (label != null)
13773  {
13774  labelByteCount = Encoding.UTF8.GetByteCount(label);
13775  if (labelByteCount > Util.StackAllocationSizeLimit)
13776  {
13777  nativeLabel = Util.Allocate(labelByteCount + 1);
13778  }
13779  else
13780  {
13781  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13782  nativeLabel = nativeLabelStackBytes;
13783  }
13784 
13785  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13786  nativeLabel[nativeLabelOffset] = 0;
13787  }
13788  else
13789  {
13790  nativeLabel = null;
13791  }
13792 
13793  byte* nativeShortcut;
13794  int shortcutByteCount = 0;
13795  if (shortcut != null)
13796  {
13797  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13798  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13799  {
13800  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13801  }
13802  else
13803  {
13804  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13805  nativeShortcut = nativeShortcutStackBytes;
13806  }
13807 
13808  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13809  nativeShortcut[nativeShortcutOffset] = 0;
13810  }
13811  else
13812  {
13813  nativeShortcut = null;
13814  }
13815 
13816  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
13817  byte* nativePSelected = &nativePSelectedVal;
13818  byte enabled = 1;
13819  byte ret = ImGuiNative.igMenuItem_BoolPtr(nativeLabel, nativeShortcut, nativePSelected, enabled);
13820  if (labelByteCount > Util.StackAllocationSizeLimit)
13821  {
13822  Util.Free(nativeLabel);
13823  }
13824 
13825  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13826  {
13827  Util.Free(nativeShortcut);
13828  }
13829 
13830  pSelected = nativePSelectedVal != 0;
13831  return ret != 0;
13832  }
13833 
13842  public static bool MenuItem(string label, string shortcut, ref bool pSelected, bool enabled)
13843  {
13844  byte* nativeLabel;
13845  int labelByteCount = 0;
13846  if (label != null)
13847  {
13848  labelByteCount = Encoding.UTF8.GetByteCount(label);
13849  if (labelByteCount > Util.StackAllocationSizeLimit)
13850  {
13851  nativeLabel = Util.Allocate(labelByteCount + 1);
13852  }
13853  else
13854  {
13855  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13856  nativeLabel = nativeLabelStackBytes;
13857  }
13858 
13859  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13860  nativeLabel[nativeLabelOffset] = 0;
13861  }
13862  else
13863  {
13864  nativeLabel = null;
13865  }
13866 
13867  byte* nativeShortcut;
13868  int shortcutByteCount = 0;
13869  if (shortcut != null)
13870  {
13871  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13872  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13873  {
13874  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13875  }
13876  else
13877  {
13878  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13879  nativeShortcut = nativeShortcutStackBytes;
13880  }
13881 
13882  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13883  nativeShortcut[nativeShortcutOffset] = 0;
13884  }
13885  else
13886  {
13887  nativeShortcut = null;
13888  }
13889 
13890  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
13891  byte* nativePSelected = &nativePSelectedVal;
13892  byte nativeEnabled = enabled ? (byte) 1 : (byte) 0;
13893  byte ret = ImGuiNative.igMenuItem_BoolPtr(nativeLabel, nativeShortcut, nativePSelected, nativeEnabled);
13894  if (labelByteCount > Util.StackAllocationSizeLimit)
13895  {
13896  Util.Free(nativeLabel);
13897  }
13898 
13899  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13900  {
13901  Util.Free(nativeShortcut);
13902  }
13903 
13904  pSelected = nativePSelectedVal != 0;
13905  return ret != 0;
13906  }
13907 
13911  public static void NewFrame()
13912  {
13913  ImGuiNative.igNewFrame();
13914  }
13915 
13919  public static void NewLine()
13920  {
13921  ImGuiNative.igNewLine();
13922  }
13923 
13927  public static void NextColumn()
13928  {
13929  ImGuiNative.igNextColumn();
13930  }
13931 
13936  public static void OpenPopup(string strId)
13937  {
13938  byte* nativeStrId;
13939  int strIdByteCount = 0;
13940  if (strId != null)
13941  {
13942  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
13943  if (strIdByteCount > Util.StackAllocationSizeLimit)
13944  {
13945  nativeStrId = Util.Allocate(strIdByteCount + 1);
13946  }
13947  else
13948  {
13949  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
13950  nativeStrId = nativeStrIdStackBytes;
13951  }
13952 
13953  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
13954  nativeStrId[nativeStrIdOffset] = 0;
13955  }
13956  else
13957  {
13958  nativeStrId = null;
13959  }
13960 
13961  ImGuiPopupFlags popupFlags = 0;
13962  ImGuiNative.igOpenPopup_Str(nativeStrId, popupFlags);
13963  if (strIdByteCount > Util.StackAllocationSizeLimit)
13964  {
13965  Util.Free(nativeStrId);
13966  }
13967  }
13968 
13974  public static void OpenPopup(string strId, ImGuiPopupFlags popupFlags)
13975  {
13976  byte* nativeStrId;
13977  int strIdByteCount = 0;
13978  if (strId != null)
13979  {
13980  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
13981  if (strIdByteCount > Util.StackAllocationSizeLimit)
13982  {
13983  nativeStrId = Util.Allocate(strIdByteCount + 1);
13984  }
13985  else
13986  {
13987  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
13988  nativeStrId = nativeStrIdStackBytes;
13989  }
13990 
13991  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
13992  nativeStrId[nativeStrIdOffset] = 0;
13993  }
13994  else
13995  {
13996  nativeStrId = null;
13997  }
13998 
13999  ImGuiNative.igOpenPopup_Str(nativeStrId, popupFlags);
14000  if (strIdByteCount > Util.StackAllocationSizeLimit)
14001  {
14002  Util.Free(nativeStrId);
14003  }
14004  }
14005 
14010  public static void OpenPopup(uint id)
14011  {
14012  ImGuiPopupFlags popupFlags = 0;
14013  ImGuiNative.igOpenPopup_ID(id, popupFlags);
14014  }
14015 
14021  public static void OpenPopup(uint id, ImGuiPopupFlags popupFlags)
14022  {
14023  ImGuiNative.igOpenPopup_ID(id, popupFlags);
14024  }
14025 
14029  public static void OpenPopupOnItemClick()
14030  {
14031  byte* nativeStrId = null;
14032  ImGuiPopupFlags popupFlags = (ImGuiPopupFlags) 1;
14033  ImGuiNative.igOpenPopupOnItemClick(nativeStrId, popupFlags);
14034  }
14035 
14040  public static void OpenPopupOnItemClick(string strId)
14041  {
14042  byte* nativeStrId;
14043  int strIdByteCount = 0;
14044  if (strId != null)
14045  {
14046  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
14047  if (strIdByteCount > Util.StackAllocationSizeLimit)
14048  {
14049  nativeStrId = Util.Allocate(strIdByteCount + 1);
14050  }
14051  else
14052  {
14053  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
14054  nativeStrId = nativeStrIdStackBytes;
14055  }
14056 
14057  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
14058  nativeStrId[nativeStrIdOffset] = 0;
14059  }
14060  else
14061  {
14062  nativeStrId = null;
14063  }
14064 
14065  ImGuiPopupFlags popupFlags = (ImGuiPopupFlags) 1;
14066  ImGuiNative.igOpenPopupOnItemClick(nativeStrId, popupFlags);
14067  if (strIdByteCount > Util.StackAllocationSizeLimit)
14068  {
14069  Util.Free(nativeStrId);
14070  }
14071  }
14072 
14078  public static void OpenPopupOnItemClick(string strId, ImGuiPopupFlags popupFlags)
14079  {
14080  byte* nativeStrId;
14081  int strIdByteCount = 0;
14082  if (strId != null)
14083  {
14084  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
14085  if (strIdByteCount > Util.StackAllocationSizeLimit)
14086  {
14087  nativeStrId = Util.Allocate(strIdByteCount + 1);
14088  }
14089  else
14090  {
14091  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
14092  nativeStrId = nativeStrIdStackBytes;
14093  }
14094 
14095  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
14096  nativeStrId[nativeStrIdOffset] = 0;
14097  }
14098  else
14099  {
14100  nativeStrId = null;
14101  }
14102 
14103  ImGuiNative.igOpenPopupOnItemClick(nativeStrId, popupFlags);
14104  if (strIdByteCount > Util.StackAllocationSizeLimit)
14105  {
14106  Util.Free(nativeStrId);
14107  }
14108  }
14109 
14116  public static void PlotHistogram(string label, ref float values, int valuesCount)
14117  {
14118  byte* nativeLabel;
14119  int labelByteCount = 0;
14120  if (label != null)
14121  {
14122  labelByteCount = Encoding.UTF8.GetByteCount(label);
14123  if (labelByteCount > Util.StackAllocationSizeLimit)
14124  {
14125  nativeLabel = Util.Allocate(labelByteCount + 1);
14126  }
14127  else
14128  {
14129  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14130  nativeLabel = nativeLabelStackBytes;
14131  }
14132 
14133  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14134  nativeLabel[nativeLabelOffset] = 0;
14135  }
14136  else
14137  {
14138  nativeLabel = null;
14139  }
14140 
14141  int valuesOffset = 0;
14142  byte* nativeOverlayText = null;
14143  float scaleMin = float.MaxValue;
14144  float scaleMax = float.MaxValue;
14145  Vector2F graphSize = new Vector2F();
14146  int stride = sizeof(float);
14147  fixed (float* nativeValues = &values)
14148  {
14149  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14150  if (labelByteCount > Util.StackAllocationSizeLimit)
14151  {
14152  Util.Free(nativeLabel);
14153  }
14154  }
14155  }
14156 
14164  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset)
14165  {
14166  byte* nativeLabel;
14167  int labelByteCount = 0;
14168  if (label != null)
14169  {
14170  labelByteCount = Encoding.UTF8.GetByteCount(label);
14171  if (labelByteCount > Util.StackAllocationSizeLimit)
14172  {
14173  nativeLabel = Util.Allocate(labelByteCount + 1);
14174  }
14175  else
14176  {
14177  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14178  nativeLabel = nativeLabelStackBytes;
14179  }
14180 
14181  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14182  nativeLabel[nativeLabelOffset] = 0;
14183  }
14184  else
14185  {
14186  nativeLabel = null;
14187  }
14188 
14189  byte* nativeOverlayText = null;
14190  float scaleMin = float.MaxValue;
14191  float scaleMax = float.MaxValue;
14192  Vector2F graphSize = new Vector2F();
14193  int stride = sizeof(float);
14194  fixed (float* nativeValues = &values)
14195  {
14196  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14197  if (labelByteCount > Util.StackAllocationSizeLimit)
14198  {
14199  Util.Free(nativeLabel);
14200  }
14201  }
14202  }
14203 
14212  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText)
14213  {
14214  byte* nativeLabel;
14215  int labelByteCount = 0;
14216  if (label != null)
14217  {
14218  labelByteCount = Encoding.UTF8.GetByteCount(label);
14219  if (labelByteCount > Util.StackAllocationSizeLimit)
14220  {
14221  nativeLabel = Util.Allocate(labelByteCount + 1);
14222  }
14223  else
14224  {
14225  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14226  nativeLabel = nativeLabelStackBytes;
14227  }
14228 
14229  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14230  nativeLabel[nativeLabelOffset] = 0;
14231  }
14232  else
14233  {
14234  nativeLabel = null;
14235  }
14236 
14237  byte* nativeOverlayText;
14238  int overlayTextByteCount = 0;
14239  if (overlayText != null)
14240  {
14241  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14242  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14243  {
14244  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14245  }
14246  else
14247  {
14248  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14249  nativeOverlayText = nativeOverlayTextStackBytes;
14250  }
14251 
14252  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14253  nativeOverlayText[nativeOverlayTextOffset] = 0;
14254  }
14255  else
14256  {
14257  nativeOverlayText = null;
14258  }
14259 
14260  float scaleMin = float.MaxValue;
14261  float scaleMax = float.MaxValue;
14262  Vector2F graphSize = new Vector2F();
14263  int stride = sizeof(float);
14264  fixed (float* nativeValues = &values)
14265  {
14266  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14267  if (labelByteCount > Util.StackAllocationSizeLimit)
14268  {
14269  Util.Free(nativeLabel);
14270  }
14271 
14272  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14273  {
14274  Util.Free(nativeOverlayText);
14275  }
14276  }
14277  }
14278 
14288  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin)
14289  {
14290  byte* nativeLabel;
14291  int labelByteCount = 0;
14292  if (label != null)
14293  {
14294  labelByteCount = Encoding.UTF8.GetByteCount(label);
14295  if (labelByteCount > Util.StackAllocationSizeLimit)
14296  {
14297  nativeLabel = Util.Allocate(labelByteCount + 1);
14298  }
14299  else
14300  {
14301  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14302  nativeLabel = nativeLabelStackBytes;
14303  }
14304 
14305  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14306  nativeLabel[nativeLabelOffset] = 0;
14307  }
14308  else
14309  {
14310  nativeLabel = null;
14311  }
14312 
14313  byte* nativeOverlayText;
14314  int overlayTextByteCount = 0;
14315  if (overlayText != null)
14316  {
14317  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14318  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14319  {
14320  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14321  }
14322  else
14323  {
14324  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14325  nativeOverlayText = nativeOverlayTextStackBytes;
14326  }
14327 
14328  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14329  nativeOverlayText[nativeOverlayTextOffset] = 0;
14330  }
14331  else
14332  {
14333  nativeOverlayText = null;
14334  }
14335 
14336  float scaleMax = float.MaxValue;
14337  Vector2F graphSize = new Vector2F();
14338  int stride = sizeof(float);
14339  fixed (float* nativeValues = &values)
14340  {
14341  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14342  if (labelByteCount > Util.StackAllocationSizeLimit)
14343  {
14344  Util.Free(nativeLabel);
14345  }
14346 
14347  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14348  {
14349  Util.Free(nativeOverlayText);
14350  }
14351  }
14352  }
14353 
14364  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax)
14365  {
14366  byte* nativeLabel;
14367  int labelByteCount = 0;
14368  if (label != null)
14369  {
14370  labelByteCount = Encoding.UTF8.GetByteCount(label);
14371  if (labelByteCount > Util.StackAllocationSizeLimit)
14372  {
14373  nativeLabel = Util.Allocate(labelByteCount + 1);
14374  }
14375  else
14376  {
14377  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14378  nativeLabel = nativeLabelStackBytes;
14379  }
14380 
14381  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14382  nativeLabel[nativeLabelOffset] = 0;
14383  }
14384  else
14385  {
14386  nativeLabel = null;
14387  }
14388 
14389  byte* nativeOverlayText;
14390  int overlayTextByteCount = 0;
14391  if (overlayText != null)
14392  {
14393  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14394  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14395  {
14396  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14397  }
14398  else
14399  {
14400  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14401  nativeOverlayText = nativeOverlayTextStackBytes;
14402  }
14403 
14404  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14405  nativeOverlayText[nativeOverlayTextOffset] = 0;
14406  }
14407  else
14408  {
14409  nativeOverlayText = null;
14410  }
14411 
14412  Vector2F graphSize = new Vector2F();
14413  int stride = sizeof(float);
14414  fixed (float* nativeValues = &values)
14415  {
14416  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14417  if (labelByteCount > Util.StackAllocationSizeLimit)
14418  {
14419  Util.Free(nativeLabel);
14420  }
14421 
14422  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14423  {
14424  Util.Free(nativeOverlayText);
14425  }
14426  }
14427  }
14428 
14440  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize)
14441  {
14442  byte* nativeLabel;
14443  int labelByteCount = 0;
14444  if (label != null)
14445  {
14446  labelByteCount = Encoding.UTF8.GetByteCount(label);
14447  if (labelByteCount > Util.StackAllocationSizeLimit)
14448  {
14449  nativeLabel = Util.Allocate(labelByteCount + 1);
14450  }
14451  else
14452  {
14453  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14454  nativeLabel = nativeLabelStackBytes;
14455  }
14456 
14457  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14458  nativeLabel[nativeLabelOffset] = 0;
14459  }
14460  else
14461  {
14462  nativeLabel = null;
14463  }
14464 
14465  byte* nativeOverlayText;
14466  int overlayTextByteCount = 0;
14467  if (overlayText != null)
14468  {
14469  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14470  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14471  {
14472  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14473  }
14474  else
14475  {
14476  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14477  nativeOverlayText = nativeOverlayTextStackBytes;
14478  }
14479 
14480  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14481  nativeOverlayText[nativeOverlayTextOffset] = 0;
14482  }
14483  else
14484  {
14485  nativeOverlayText = null;
14486  }
14487 
14488  int stride = sizeof(float);
14489  fixed (float* nativeValues = &values)
14490  {
14491  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14492  if (labelByteCount > Util.StackAllocationSizeLimit)
14493  {
14494  Util.Free(nativeLabel);
14495  }
14496 
14497  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14498  {
14499  Util.Free(nativeOverlayText);
14500  }
14501  }
14502  }
14503 
14516  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
14517  {
14518  byte* nativeLabel;
14519  int labelByteCount = 0;
14520  if (label != null)
14521  {
14522  labelByteCount = Encoding.UTF8.GetByteCount(label);
14523  if (labelByteCount > Util.StackAllocationSizeLimit)
14524  {
14525  nativeLabel = Util.Allocate(labelByteCount + 1);
14526  }
14527  else
14528  {
14529  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14530  nativeLabel = nativeLabelStackBytes;
14531  }
14532 
14533  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14534  nativeLabel[nativeLabelOffset] = 0;
14535  }
14536  else
14537  {
14538  nativeLabel = null;
14539  }
14540 
14541  byte* nativeOverlayText;
14542  int overlayTextByteCount = 0;
14543  if (overlayText != null)
14544  {
14545  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14546  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14547  {
14548  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14549  }
14550  else
14551  {
14552  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14553  nativeOverlayText = nativeOverlayTextStackBytes;
14554  }
14555 
14556  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14557  nativeOverlayText[nativeOverlayTextOffset] = 0;
14558  }
14559  else
14560  {
14561  nativeOverlayText = null;
14562  }
14563 
14564  fixed (float* nativeValues = &values)
14565  {
14566  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14567  if (labelByteCount > Util.StackAllocationSizeLimit)
14568  {
14569  Util.Free(nativeLabel);
14570  }
14571 
14572  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14573  {
14574  Util.Free(nativeOverlayText);
14575  }
14576  }
14577  }
14578 
14585  public static void PlotLines(string label, ref float values, int valuesCount)
14586  {
14587  byte* nativeLabel;
14588  int labelByteCount = 0;
14589  if (label != null)
14590  {
14591  labelByteCount = Encoding.UTF8.GetByteCount(label);
14592  if (labelByteCount > Util.StackAllocationSizeLimit)
14593  {
14594  nativeLabel = Util.Allocate(labelByteCount + 1);
14595  }
14596  else
14597  {
14598  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14599  nativeLabel = nativeLabelStackBytes;
14600  }
14601 
14602  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14603  nativeLabel[nativeLabelOffset] = 0;
14604  }
14605  else
14606  {
14607  nativeLabel = null;
14608  }
14609 
14610  int valuesOffset = 0;
14611  byte* nativeOverlayText = null;
14612  float scaleMin = float.MaxValue;
14613  float scaleMax = float.MaxValue;
14614  Vector2F graphSize = new Vector2F();
14615  int stride = sizeof(float);
14616  fixed (float* nativeValues = &values)
14617  {
14618  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14619  if (labelByteCount > Util.StackAllocationSizeLimit)
14620  {
14621  Util.Free(nativeLabel);
14622  }
14623  }
14624  }
14625 
14633  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset)
14634  {
14635  byte* nativeLabel;
14636  int labelByteCount = 0;
14637  if (label != null)
14638  {
14639  labelByteCount = Encoding.UTF8.GetByteCount(label);
14640  if (labelByteCount > Util.StackAllocationSizeLimit)
14641  {
14642  nativeLabel = Util.Allocate(labelByteCount + 1);
14643  }
14644  else
14645  {
14646  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14647  nativeLabel = nativeLabelStackBytes;
14648  }
14649 
14650  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14651  nativeLabel[nativeLabelOffset] = 0;
14652  }
14653  else
14654  {
14655  nativeLabel = null;
14656  }
14657 
14658  byte* nativeOverlayText = null;
14659  float scaleMin = float.MaxValue;
14660  float scaleMax = float.MaxValue;
14661  Vector2F graphSize = new Vector2F();
14662  int stride = sizeof(float);
14663  fixed (float* nativeValues = &values)
14664  {
14665  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14666  if (labelByteCount > Util.StackAllocationSizeLimit)
14667  {
14668  Util.Free(nativeLabel);
14669  }
14670  }
14671  }
14672 
14681  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText)
14682  {
14683  byte* nativeLabel;
14684  int labelByteCount = 0;
14685  if (label != null)
14686  {
14687  labelByteCount = Encoding.UTF8.GetByteCount(label);
14688  if (labelByteCount > Util.StackAllocationSizeLimit)
14689  {
14690  nativeLabel = Util.Allocate(labelByteCount + 1);
14691  }
14692  else
14693  {
14694  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14695  nativeLabel = nativeLabelStackBytes;
14696  }
14697 
14698  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14699  nativeLabel[nativeLabelOffset] = 0;
14700  }
14701  else
14702  {
14703  nativeLabel = null;
14704  }
14705 
14706  byte* nativeOverlayText;
14707  int overlayTextByteCount = 0;
14708  if (overlayText != null)
14709  {
14710  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14711  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14712  {
14713  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14714  }
14715  else
14716  {
14717  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14718  nativeOverlayText = nativeOverlayTextStackBytes;
14719  }
14720 
14721  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14722  nativeOverlayText[nativeOverlayTextOffset] = 0;
14723  }
14724  else
14725  {
14726  nativeOverlayText = null;
14727  }
14728 
14729  float scaleMin = float.MaxValue;
14730  float scaleMax = float.MaxValue;
14731  Vector2F graphSize = new Vector2F();
14732  int stride = sizeof(float);
14733  fixed (float* nativeValues = &values)
14734  {
14735  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14736  if (labelByteCount > Util.StackAllocationSizeLimit)
14737  {
14738  Util.Free(nativeLabel);
14739  }
14740 
14741  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14742  {
14743  Util.Free(nativeOverlayText);
14744  }
14745  }
14746  }
14747 
14757  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin)
14758  {
14759  byte* nativeLabel;
14760  int labelByteCount = 0;
14761  if (label != null)
14762  {
14763  labelByteCount = Encoding.UTF8.GetByteCount(label);
14764  if (labelByteCount > Util.StackAllocationSizeLimit)
14765  {
14766  nativeLabel = Util.Allocate(labelByteCount + 1);
14767  }
14768  else
14769  {
14770  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14771  nativeLabel = nativeLabelStackBytes;
14772  }
14773 
14774  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14775  nativeLabel[nativeLabelOffset] = 0;
14776  }
14777  else
14778  {
14779  nativeLabel = null;
14780  }
14781 
14782  byte* nativeOverlayText;
14783  int overlayTextByteCount = 0;
14784  if (overlayText != null)
14785  {
14786  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14787  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14788  {
14789  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14790  }
14791  else
14792  {
14793  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14794  nativeOverlayText = nativeOverlayTextStackBytes;
14795  }
14796 
14797  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14798  nativeOverlayText[nativeOverlayTextOffset] = 0;
14799  }
14800  else
14801  {
14802  nativeOverlayText = null;
14803  }
14804 
14805  float scaleMax = float.MaxValue;
14806  Vector2F graphSize = new Vector2F();
14807  int stride = sizeof(float);
14808  fixed (float* nativeValues = &values)
14809  {
14810  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14811  if (labelByteCount > Util.StackAllocationSizeLimit)
14812  {
14813  Util.Free(nativeLabel);
14814  }
14815 
14816  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14817  {
14818  Util.Free(nativeOverlayText);
14819  }
14820  }
14821  }
14822 
14833  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax)
14834  {
14835  byte* nativeLabel;
14836  int labelByteCount = 0;
14837  if (label != null)
14838  {
14839  labelByteCount = Encoding.UTF8.GetByteCount(label);
14840  if (labelByteCount > Util.StackAllocationSizeLimit)
14841  {
14842  nativeLabel = Util.Allocate(labelByteCount + 1);
14843  }
14844  else
14845  {
14846  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14847  nativeLabel = nativeLabelStackBytes;
14848  }
14849 
14850  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14851  nativeLabel[nativeLabelOffset] = 0;
14852  }
14853  else
14854  {
14855  nativeLabel = null;
14856  }
14857 
14858  byte* nativeOverlayText;
14859  int overlayTextByteCount = 0;
14860  if (overlayText != null)
14861  {
14862  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14863  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14864  {
14865  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14866  }
14867  else
14868  {
14869  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14870  nativeOverlayText = nativeOverlayTextStackBytes;
14871  }
14872 
14873  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14874  nativeOverlayText[nativeOverlayTextOffset] = 0;
14875  }
14876  else
14877  {
14878  nativeOverlayText = null;
14879  }
14880 
14881  Vector2F graphSize = new Vector2F();
14882  int stride = sizeof(float);
14883  fixed (float* nativeValues = &values)
14884  {
14885  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14886  if (labelByteCount > Util.StackAllocationSizeLimit)
14887  {
14888  Util.Free(nativeLabel);
14889  }
14890 
14891  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14892  {
14893  Util.Free(nativeOverlayText);
14894  }
14895  }
14896  }
14897 
14909  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize)
14910  {
14911  byte* nativeLabel;
14912  int labelByteCount = 0;
14913  if (label != null)
14914  {
14915  labelByteCount = Encoding.UTF8.GetByteCount(label);
14916  if (labelByteCount > Util.StackAllocationSizeLimit)
14917  {
14918  nativeLabel = Util.Allocate(labelByteCount + 1);
14919  }
14920  else
14921  {
14922  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14923  nativeLabel = nativeLabelStackBytes;
14924  }
14925 
14926  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14927  nativeLabel[nativeLabelOffset] = 0;
14928  }
14929  else
14930  {
14931  nativeLabel = null;
14932  }
14933 
14934  byte* nativeOverlayText;
14935  int overlayTextByteCount = 0;
14936  if (overlayText != null)
14937  {
14938  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14939  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14940  {
14941  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14942  }
14943  else
14944  {
14945  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14946  nativeOverlayText = nativeOverlayTextStackBytes;
14947  }
14948 
14949  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14950  nativeOverlayText[nativeOverlayTextOffset] = 0;
14951  }
14952  else
14953  {
14954  nativeOverlayText = null;
14955  }
14956 
14957  int stride = sizeof(float);
14958  fixed (float* nativeValues = &values)
14959  {
14960  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14961  if (labelByteCount > Util.StackAllocationSizeLimit)
14962  {
14963  Util.Free(nativeLabel);
14964  }
14965 
14966  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14967  {
14968  Util.Free(nativeOverlayText);
14969  }
14970  }
14971  }
14972 
14985  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
14986  {
14987  byte* nativeLabel;
14988  int labelByteCount = 0;
14989  if (label != null)
14990  {
14991  labelByteCount = Encoding.UTF8.GetByteCount(label);
14992  if (labelByteCount > Util.StackAllocationSizeLimit)
14993  {
14994  nativeLabel = Util.Allocate(labelByteCount + 1);
14995  }
14996  else
14997  {
14998  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14999  nativeLabel = nativeLabelStackBytes;
15000  }
15001 
15002  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15003  nativeLabel[nativeLabelOffset] = 0;
15004  }
15005  else
15006  {
15007  nativeLabel = null;
15008  }
15009 
15010  byte* nativeOverlayText;
15011  int overlayTextByteCount = 0;
15012  if (overlayText != null)
15013  {
15014  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
15015  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
15016  {
15017  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
15018  }
15019  else
15020  {
15021  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
15022  nativeOverlayText = nativeOverlayTextStackBytes;
15023  }
15024 
15025  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
15026  nativeOverlayText[nativeOverlayTextOffset] = 0;
15027  }
15028  else
15029  {
15030  nativeOverlayText = null;
15031  }
15032 
15033  fixed (float* nativeValues = &values)
15034  {
15035  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
15036  if (labelByteCount > Util.StackAllocationSizeLimit)
15037  {
15038  Util.Free(nativeLabel);
15039  }
15040 
15041  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
15042  {
15043  Util.Free(nativeOverlayText);
15044  }
15045  }
15046  }
15047 
15051  public static void PopButtonRepeat()
15052  {
15053  ImGuiNative.igPopButtonRepeat();
15054  }
15055 
15059  public static void PopClipRect()
15060  {
15061  ImGuiNative.igPopClipRect();
15062  }
15063 
15067  public static void PopFont()
15068  {
15069  ImGuiNative.igPopFont();
15070  }
15071 
15075  public static void PopId()
15076  {
15077  ImGuiNative.igPopID();
15078  }
15079 
15083  public static void PopItemWidth()
15084  {
15085  ImGuiNative.igPopItemWidth();
15086  }
15087 
15091  public static void PopStyleColor()
15092  {
15093  int count = 1;
15094  ImGuiNative.igPopStyleColor(count);
15095  }
15096 
15101  public static void PopStyleColor(int count)
15102  {
15103  ImGuiNative.igPopStyleColor(count);
15104  }
15105 
15109  public static void PopStyleVar()
15110  {
15111  int count = 1;
15112  ImGuiNative.igPopStyleVar(count);
15113  }
15114 
15119  public static void PopStyleVar(int count)
15120  {
15121  ImGuiNative.igPopStyleVar(count);
15122  }
15123 
15127  public static void PopTabStop()
15128  {
15129  ImGuiNative.igPopTabStop();
15130  }
15131 
15135  public static void PopTextWrapPos()
15136  {
15137  ImGuiNative.igPopTextWrapPos();
15138  }
15139 
15144  public static void ProgressBar(float fraction)
15145  {
15146  Vector2F sizeArg = new Vector2F(-float.MinValue, 0.0f);
15147  byte* nativeOverlay = null;
15148  ImGuiNative.igProgressBar(fraction, sizeArg, nativeOverlay);
15149  }
15150 
15156  public static void ProgressBar(float fraction, Vector2F sizeArg)
15157  {
15158  byte* nativeOverlay = null;
15159  ImGuiNative.igProgressBar(fraction, sizeArg, nativeOverlay);
15160  }
15161 
15168  public static void ProgressBar(float fraction, Vector2F sizeArg, string overlay)
15169  {
15170  byte* nativeOverlay;
15171  int overlayByteCount = 0;
15172  if (overlay != null)
15173  {
15174  overlayByteCount = Encoding.UTF8.GetByteCount(overlay);
15175  if (overlayByteCount > Util.StackAllocationSizeLimit)
15176  {
15177  nativeOverlay = Util.Allocate(overlayByteCount + 1);
15178  }
15179  else
15180  {
15181  byte* nativeOverlayStackBytes = stackalloc byte[overlayByteCount + 1];
15182  nativeOverlay = nativeOverlayStackBytes;
15183  }
15184 
15185  int nativeOverlayOffset = Util.GetUtf8(overlay, nativeOverlay, overlayByteCount);
15186  nativeOverlay[nativeOverlayOffset] = 0;
15187  }
15188  else
15189  {
15190  nativeOverlay = null;
15191  }
15192 
15193  ImGuiNative.igProgressBar(fraction, sizeArg, nativeOverlay);
15194  if (overlayByteCount > Util.StackAllocationSizeLimit)
15195  {
15196  Util.Free(nativeOverlay);
15197  }
15198  }
15199 
15204  public static void PushButtonRepeat(bool repeat)
15205  {
15206  byte nativeRepeat = repeat ? (byte) 1 : (byte) 0;
15207  ImGuiNative.igPushButtonRepeat(nativeRepeat);
15208  }
15209 
15216  public static void PushClipRect(Vector2F clipRectMin, Vector2F clipRectMax, bool intersectWithCurrentClipRect)
15217  {
15218  byte nativeIntersectWithCurrentClipRect = intersectWithCurrentClipRect ? (byte) 1 : (byte) 0;
15219  ImGuiNative.igPushClipRect(clipRectMin, clipRectMax, nativeIntersectWithCurrentClipRect);
15220  }
15221 
15226  public static void PushFont(ImFontPtr font)
15227  {
15228  ImFont* nativeFont = font.NativePtr;
15229  ImGuiNative.igPushFont(nativeFont);
15230  }
15231 
15236  public static void PushId(string strId)
15237  {
15238  byte* nativeStrId;
15239  int strIdByteCount = 0;
15240  if (strId != null)
15241  {
15242  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
15243  if (strIdByteCount > Util.StackAllocationSizeLimit)
15244  {
15245  nativeStrId = Util.Allocate(strIdByteCount + 1);
15246  }
15247  else
15248  {
15249  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
15250  nativeStrId = nativeStrIdStackBytes;
15251  }
15252 
15253  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
15254  nativeStrId[nativeStrIdOffset] = 0;
15255  }
15256  else
15257  {
15258  nativeStrId = null;
15259  }
15260 
15261  ImGuiNative.igPushID_Str(nativeStrId);
15262  if (strIdByteCount > Util.StackAllocationSizeLimit)
15263  {
15264  Util.Free(nativeStrId);
15265  }
15266  }
15267 
15272  public static void PushId(IntPtr ptrId)
15273  {
15274  void* nativePtrId = ptrId.ToPointer();
15275  ImGuiNative.igPushID_Ptr(nativePtrId);
15276  }
15277 
15282  public static void PushId(int intId)
15283  {
15284  ImGuiNative.igPushID_Int(intId);
15285  }
15286 
15291  public static void PushItemWidth(float itemWidth)
15292  {
15293  ImGuiNative.igPushItemWidth(itemWidth);
15294  }
15295 
15301  public static void PushStyleColor(ImGuiCol idx, uint col)
15302  {
15303  ImGuiNative.igPushStyleColor_U32(idx, col);
15304  }
15305 
15311  public static void PushStyleColor(ImGuiCol idx, Vector4F col)
15312  {
15313  ImGuiNative.igPushStyleColor_Vec4(idx, col);
15314  }
15315 
15321  public static void PushStyleVar(ImGuiStyleVar idx, float val)
15322  {
15323  ImGuiNative.igPushStyleVar_Float(idx, val);
15324  }
15325 
15331  public static void PushStyleVar(ImGuiStyleVar idx, Vector2F val)
15332  {
15333  ImGuiNative.igPushStyleVar_Vec2(idx, val);
15334  }
15335 
15340  public static void PushTabStop(bool tabStop)
15341  {
15342  byte nativeTabStop = tabStop ? (byte) 1 : (byte) 0;
15343  ImGuiNative.igPushTabStop(nativeTabStop);
15344  }
15345 
15349  public static void PushTextWrapPos()
15350  {
15351  float wrapLocalPosX = 0.0f;
15352  ImGuiNative.igPushTextWrapPos(wrapLocalPosX);
15353  }
15354 
15359  public static void PushTextWrapPos(float wrapLocalPosX)
15360  {
15361  ImGuiNative.igPushTextWrapPos(wrapLocalPosX);
15362  }
15363 
15370  public static bool RadioButton(string label, bool active)
15371  {
15372  byte* nativeLabel;
15373  int labelByteCount = 0;
15374  if (label != null)
15375  {
15376  labelByteCount = Encoding.UTF8.GetByteCount(label);
15377  if (labelByteCount > Util.StackAllocationSizeLimit)
15378  {
15379  nativeLabel = Util.Allocate(labelByteCount + 1);
15380  }
15381  else
15382  {
15383  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15384  nativeLabel = nativeLabelStackBytes;
15385  }
15386 
15387  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15388  nativeLabel[nativeLabelOffset] = 0;
15389  }
15390  else
15391  {
15392  nativeLabel = null;
15393  }
15394 
15395  byte nativeActive = active ? (byte) 1 : (byte) 0;
15396  byte ret = ImGuiNative.igRadioButton_Bool(nativeLabel, nativeActive);
15397  if (labelByteCount > Util.StackAllocationSizeLimit)
15398  {
15399  Util.Free(nativeLabel);
15400  }
15401 
15402  return ret != 0;
15403  }
15404 
15412  public static bool RadioButton(string label, ref int v, int vButton)
15413  {
15414  byte* nativeLabel;
15415  int labelByteCount = 0;
15416  if (label != null)
15417  {
15418  labelByteCount = Encoding.UTF8.GetByteCount(label);
15419  if (labelByteCount > Util.StackAllocationSizeLimit)
15420  {
15421  nativeLabel = Util.Allocate(labelByteCount + 1);
15422  }
15423  else
15424  {
15425  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15426  nativeLabel = nativeLabelStackBytes;
15427  }
15428 
15429  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15430  nativeLabel[nativeLabelOffset] = 0;
15431  }
15432  else
15433  {
15434  nativeLabel = null;
15435  }
15436 
15437  fixed (int* nativeV = &v)
15438  {
15439  byte ret = ImGuiNative.igRadioButton_IntPtr(nativeLabel, nativeV, vButton);
15440  if (labelByteCount > Util.StackAllocationSizeLimit)
15441  {
15442  Util.Free(nativeLabel);
15443  }
15444 
15445  return ret != 0;
15446  }
15447  }
15448 
15452  public static void Render()
15453  {
15454  ImGuiNative.igRender();
15455  }
15456 
15460  public static void RenderPlatformWindowsDefault()
15461  {
15462  void* platformRenderArg = null;
15463  void* rendererRenderArg = null;
15464  ImGuiNative.igRenderPlatformWindowsDefault(platformRenderArg, rendererRenderArg);
15465  }
15466 
15471  public static void RenderPlatformWindowsDefault(IntPtr platformRenderArg)
15472  {
15473  void* nativePlatformRenderArg = platformRenderArg.ToPointer();
15474  void* rendererRenderArg = null;
15475  ImGuiNative.igRenderPlatformWindowsDefault(nativePlatformRenderArg, rendererRenderArg);
15476  }
15477 
15483  public static void RenderPlatformWindowsDefault(IntPtr platformRenderArg, IntPtr rendererRenderArg)
15484  {
15485  void* nativePlatformRenderArg = platformRenderArg.ToPointer();
15486  void* nativeRendererRenderArg = rendererRenderArg.ToPointer();
15487  ImGuiNative.igRenderPlatformWindowsDefault(nativePlatformRenderArg, nativeRendererRenderArg);
15488  }
15489 
15493  public static void ResetMouseDragDelta()
15494  {
15495  ImGuiMouseButton button = 0;
15496  ImGuiNative.igResetMouseDragDelta(button);
15497  }
15498 
15503  public static void ResetMouseDragDelta(ImGuiMouseButton button)
15504  {
15505  ImGuiNative.igResetMouseDragDelta(button);
15506  }
15507 
15511  public static void SameLine()
15512  {
15513  float offsetFromStartX = 0.0f;
15514  float spacing = -1.0f;
15515  ImGuiNative.igSameLine(offsetFromStartX, spacing);
15516  }
15517 
15522  public static void SameLine(float offsetFromStartX)
15523  {
15524  float spacing = -1.0f;
15525  ImGuiNative.igSameLine(offsetFromStartX, spacing);
15526  }
15527 
15533  public static void SameLine(float offsetFromStartX, float spacing)
15534  {
15535  ImGuiNative.igSameLine(offsetFromStartX, spacing);
15536  }
15537 
15542  public static void SaveIniSettingsToDisk(string iniFilename)
15543  {
15544  byte* nativeIniFilename;
15545  int iniFilenameByteCount = 0;
15546  if (iniFilename != null)
15547  {
15548  iniFilenameByteCount = Encoding.UTF8.GetByteCount(iniFilename);
15549  if (iniFilenameByteCount > Util.StackAllocationSizeLimit)
15550  {
15551  nativeIniFilename = Util.Allocate(iniFilenameByteCount + 1);
15552  }
15553  else
15554  {
15555  byte* nativeIniFilenameStackBytes = stackalloc byte[iniFilenameByteCount + 1];
15556  nativeIniFilename = nativeIniFilenameStackBytes;
15557  }
15558 
15559  int nativeIniFilenameOffset = Util.GetUtf8(iniFilename, nativeIniFilename, iniFilenameByteCount);
15560  nativeIniFilename[nativeIniFilenameOffset] = 0;
15561  }
15562  else
15563  {
15564  nativeIniFilename = null;
15565  }
15566 
15567  ImGuiNative.igSaveIniSettingsToDisk(nativeIniFilename);
15568  if (iniFilenameByteCount > Util.StackAllocationSizeLimit)
15569  {
15570  Util.Free(nativeIniFilename);
15571  }
15572  }
15573 
15578  public static string SaveIniSettingsToMemory()
15579  {
15580  uint* outIniSize = null;
15581  byte* ret = ImGuiNative.igSaveIniSettingsToMemory(outIniSize);
15582  return Util.StringFromPtr(ret);
15583  }
15584 
15590  public static string SaveIniSettingsToMemory(out uint outIniSize)
15591  {
15592  fixed (uint* nativeOutIniSize = &outIniSize)
15593  {
15594  byte* ret = ImGuiNative.igSaveIniSettingsToMemory(nativeOutIniSize);
15595  return Util.StringFromPtr(ret);
15596  }
15597  }
15598 
15604  public static bool Selectable(string label)
15605  {
15606  byte* nativeLabel;
15607  int labelByteCount = 0;
15608  if (label != null)
15609  {
15610  labelByteCount = Encoding.UTF8.GetByteCount(label);
15611  if (labelByteCount > Util.StackAllocationSizeLimit)
15612  {
15613  nativeLabel = Util.Allocate(labelByteCount + 1);
15614  }
15615  else
15616  {
15617  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15618  nativeLabel = nativeLabelStackBytes;
15619  }
15620 
15621  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15622  nativeLabel[nativeLabelOffset] = 0;
15623  }
15624  else
15625  {
15626  nativeLabel = null;
15627  }
15628 
15629  byte selected = 0;
15630  ImGuiSelectableFlags flags = 0;
15631  Vector2F size = new Vector2F();
15632  byte ret = ImGuiNative.igSelectable_Bool(nativeLabel, selected, flags, size);
15633  if (labelByteCount > Util.StackAllocationSizeLimit)
15634  {
15635  Util.Free(nativeLabel);
15636  }
15637 
15638  return ret != 0;
15639  }
15640 
15647  public static bool Selectable(string label, bool selected)
15648  {
15649  byte* nativeLabel;
15650  int labelByteCount = 0;
15651  if (label != null)
15652  {
15653  labelByteCount = Encoding.UTF8.GetByteCount(label);
15654  if (labelByteCount > Util.StackAllocationSizeLimit)
15655  {
15656  nativeLabel = Util.Allocate(labelByteCount + 1);
15657  }
15658  else
15659  {
15660  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15661  nativeLabel = nativeLabelStackBytes;
15662  }
15663 
15664  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15665  nativeLabel[nativeLabelOffset] = 0;
15666  }
15667  else
15668  {
15669  nativeLabel = null;
15670  }
15671 
15672  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
15673  ImGuiSelectableFlags flags = 0;
15674  Vector2F size = new Vector2F();
15675  byte ret = ImGuiNative.igSelectable_Bool(nativeLabel, nativeSelected, flags, size);
15676  if (labelByteCount > Util.StackAllocationSizeLimit)
15677  {
15678  Util.Free(nativeLabel);
15679  }
15680 
15681  return ret != 0;
15682  }
15683 
15691  public static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags)
15692  {
15693  byte* nativeLabel;
15694  int labelByteCount = 0;
15695  if (label != null)
15696  {
15697  labelByteCount = Encoding.UTF8.GetByteCount(label);
15698  if (labelByteCount > Util.StackAllocationSizeLimit)
15699  {
15700  nativeLabel = Util.Allocate(labelByteCount + 1);
15701  }
15702  else
15703  {
15704  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15705  nativeLabel = nativeLabelStackBytes;
15706  }
15707 
15708  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15709  nativeLabel[nativeLabelOffset] = 0;
15710  }
15711  else
15712  {
15713  nativeLabel = null;
15714  }
15715 
15716  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
15717  Vector2F size = new Vector2F();
15718  byte ret = ImGuiNative.igSelectable_Bool(nativeLabel, nativeSelected, flags, size);
15719  if (labelByteCount > Util.StackAllocationSizeLimit)
15720  {
15721  Util.Free(nativeLabel);
15722  }
15723 
15724  return ret != 0;
15725  }
15726 
15735  public static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags, Vector2F size)
15736  {
15737  byte* nativeLabel;
15738  int labelByteCount = 0;
15739  if (label != null)
15740  {
15741  labelByteCount = Encoding.UTF8.GetByteCount(label);
15742  if (labelByteCount > Util.StackAllocationSizeLimit)
15743  {
15744  nativeLabel = Util.Allocate(labelByteCount + 1);
15745  }
15746  else
15747  {
15748  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15749  nativeLabel = nativeLabelStackBytes;
15750  }
15751 
15752  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15753  nativeLabel[nativeLabelOffset] = 0;
15754  }
15755  else
15756  {
15757  nativeLabel = null;
15758  }
15759 
15760  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
15761  byte ret = ImGuiNative.igSelectable_Bool(nativeLabel, nativeSelected, flags, size);
15762  if (labelByteCount > Util.StackAllocationSizeLimit)
15763  {
15764  Util.Free(nativeLabel);
15765  }
15766 
15767  return ret != 0;
15768  }
15769 
15776  public static bool Selectable(string label, ref bool pSelected)
15777  {
15778  byte* nativeLabel;
15779  int labelByteCount = 0;
15780  if (label != null)
15781  {
15782  labelByteCount = Encoding.UTF8.GetByteCount(label);
15783  if (labelByteCount > Util.StackAllocationSizeLimit)
15784  {
15785  nativeLabel = Util.Allocate(labelByteCount + 1);
15786  }
15787  else
15788  {
15789  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15790  nativeLabel = nativeLabelStackBytes;
15791  }
15792 
15793  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15794  nativeLabel[nativeLabelOffset] = 0;
15795  }
15796  else
15797  {
15798  nativeLabel = null;
15799  }
15800 
15801  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
15802  byte* nativePSelected = &nativePSelectedVal;
15803  ImGuiSelectableFlags flags = 0;
15804  Vector2F size = new Vector2F();
15805  byte ret = ImGuiNative.igSelectable_BoolPtr(nativeLabel, nativePSelected, flags, size);
15806  if (labelByteCount > Util.StackAllocationSizeLimit)
15807  {
15808  Util.Free(nativeLabel);
15809  }
15810 
15811  pSelected = nativePSelectedVal != 0;
15812  return ret != 0;
15813  }
15814 
15822  public static bool Selectable(string label, ref bool pSelected, ImGuiSelectableFlags flags)
15823  {
15824  byte* nativeLabel;
15825  int labelByteCount = 0;
15826  if (label != null)
15827  {
15828  labelByteCount = Encoding.UTF8.GetByteCount(label);
15829  if (labelByteCount > Util.StackAllocationSizeLimit)
15830  {
15831  nativeLabel = Util.Allocate(labelByteCount + 1);
15832  }
15833  else
15834  {
15835  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15836  nativeLabel = nativeLabelStackBytes;
15837  }
15838 
15839  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15840  nativeLabel[nativeLabelOffset] = 0;
15841  }
15842  else
15843  {
15844  nativeLabel = null;
15845  }
15846 
15847  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
15848  byte* nativePSelected = &nativePSelectedVal;
15849  Vector2F size = new Vector2F();
15850  byte ret = ImGuiNative.igSelectable_BoolPtr(nativeLabel, nativePSelected, flags, size);
15851  if (labelByteCount > Util.StackAllocationSizeLimit)
15852  {
15853  Util.Free(nativeLabel);
15854  }
15855 
15856  pSelected = nativePSelectedVal != 0;
15857  return ret != 0;
15858  }
15859 
15868  public static bool Selectable(string label, ref bool pSelected, ImGuiSelectableFlags flags, Vector2F size)
15869  {
15870  byte* nativeLabel;
15871  int labelByteCount = 0;
15872  if (label != null)
15873  {
15874  labelByteCount = Encoding.UTF8.GetByteCount(label);
15875  if (labelByteCount > Util.StackAllocationSizeLimit)
15876  {
15877  nativeLabel = Util.Allocate(labelByteCount + 1);
15878  }
15879  else
15880  {
15881  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15882  nativeLabel = nativeLabelStackBytes;
15883  }
15884 
15885  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15886  nativeLabel[nativeLabelOffset] = 0;
15887  }
15888  else
15889  {
15890  nativeLabel = null;
15891  }
15892 
15893  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
15894  byte* nativePSelected = &nativePSelectedVal;
15895  byte ret = ImGuiNative.igSelectable_BoolPtr(nativeLabel, nativePSelected, flags, size);
15896  if (labelByteCount > Util.StackAllocationSizeLimit)
15897  {
15898  Util.Free(nativeLabel);
15899  }
15900 
15901  pSelected = nativePSelectedVal != 0;
15902  return ret != 0;
15903  }
15904 
15908  public static void Separator()
15909  {
15910  ImGuiNative.igSeparator();
15911  }
15912 
15917  public static void SeparatorText(string label)
15918  {
15919  byte* nativeLabel;
15920  int labelByteCount = 0;
15921  if (label != null)
15922  {
15923  labelByteCount = Encoding.UTF8.GetByteCount(label);
15924  if (labelByteCount > Util.StackAllocationSizeLimit)
15925  {
15926  nativeLabel = Util.Allocate(labelByteCount + 1);
15927  }
15928  else
15929  {
15930  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15931  nativeLabel = nativeLabelStackBytes;
15932  }
15933 
15934  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15935  nativeLabel[nativeLabelOffset] = 0;
15936  }
15937  else
15938  {
15939  nativeLabel = null;
15940  }
15941 
15942  ImGuiNative.igSeparatorText(nativeLabel);
15943  if (labelByteCount > Util.StackAllocationSizeLimit)
15944  {
15945  Util.Free(nativeLabel);
15946  }
15947  }
15948 
15954  public static void SetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc)
15955  {
15956  void* userData = null;
15957  ImGuiNative.igSetAllocatorFunctions(allocFunc, freeFunc, userData);
15958  }
15959 
15966  public static void SetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc, IntPtr userData)
15967  {
15968  void* nativeUserData = userData.ToPointer();
15969  ImGuiNative.igSetAllocatorFunctions(allocFunc, freeFunc, nativeUserData);
15970  }
15971 
15976  public static void SetClipboardText(string text)
15977  {
15978  byte* nativeText;
15979  int textByteCount = 0;
15980  if (text != null)
15981  {
15982  textByteCount = Encoding.UTF8.GetByteCount(text);
15983  if (textByteCount > Util.StackAllocationSizeLimit)
15984  {
15985  nativeText = Util.Allocate(textByteCount + 1);
15986  }
15987  else
15988  {
15989  byte* nativeTextStackBytes = stackalloc byte[textByteCount + 1];
15990  nativeText = nativeTextStackBytes;
15991  }
15992 
15993  int nativeTextOffset = Util.GetUtf8(text, nativeText, textByteCount);
15994  nativeText[nativeTextOffset] = 0;
15995  }
15996  else
15997  {
15998  nativeText = null;
15999  }
16000 
16001  ImGuiNative.igSetClipboardText(nativeText);
16002  if (textByteCount > Util.StackAllocationSizeLimit)
16003  {
16004  Util.Free(nativeText);
16005  }
16006  }
16007 
16012  public static void SetColorEditOptions(ImGuiColorEditFlags flags)
16013  {
16014  ImGuiNative.igSetColorEditOptions(flags);
16015  }
16016 
16022  public static void SetColumnOffset(int columnIndex, float offsetX)
16023  {
16024  ImGuiNative.igSetColumnOffset(columnIndex, offsetX);
16025  }
16026 
16032  public static void SetColumnWidth(int columnIndex, float width)
16033  {
16034  ImGuiNative.igSetColumnWidth(columnIndex, width);
16035  }
16036 
16041  public static void SetCurrentContext(IntPtr ctx)
16042  {
16043  ImGuiNative.igSetCurrentContext(ctx);
16044  }
16045 
16050  public static void SetCursorPos(Vector2F localPos)
16051  {
16052  ImGuiNative.igSetCursorPos(localPos);
16053  }
16054 
16059  public static void SetCursorPosX(float localX)
16060  {
16061  ImGuiNative.igSetCursorPosX(localX);
16062  }
16063 
16068  public static void SetCursorPosY(float localY)
16069  {
16070  ImGuiNative.igSetCursorPosY(localY);
16071  }
16072 
16077  public static void SetCursorScreenPos(Vector2F pos)
16078  {
16079  ImGuiNative.igSetCursorScreenPos(pos);
16080  }
16081 
16089  public static bool SetDragDropPayload(string type, IntPtr data, uint sz)
16090  {
16091  byte* nativeType;
16092  int typeByteCount = 0;
16093  if (type != null)
16094  {
16095  typeByteCount = Encoding.UTF8.GetByteCount(type);
16096  if (typeByteCount > Util.StackAllocationSizeLimit)
16097  {
16098  nativeType = Util.Allocate(typeByteCount + 1);
16099  }
16100  else
16101  {
16102  byte* nativeTypeStackBytes = stackalloc byte[typeByteCount + 1];
16103  nativeType = nativeTypeStackBytes;
16104  }
16105 
16106  int nativeTypeOffset = Util.GetUtf8(type, nativeType, typeByteCount);
16107  nativeType[nativeTypeOffset] = 0;
16108  }
16109  else
16110  {
16111  nativeType = null;
16112  }
16113 
16114  void* nativeData = data.ToPointer();
16115  ImGuiCond cond = 0;
16116  byte ret = ImGuiNative.igSetDragDropPayload(nativeType, nativeData, sz, cond);
16117  if (typeByteCount > Util.StackAllocationSizeLimit)
16118  {
16119  Util.Free(nativeType);
16120  }
16121 
16122  return ret != 0;
16123  }
16124 
16133  public static bool SetDragDropPayload(string type, IntPtr data, uint sz, ImGuiCond cond)
16134  {
16135  byte* nativeType;
16136  int typeByteCount = 0;
16137  if (type != null)
16138  {
16139  typeByteCount = Encoding.UTF8.GetByteCount(type);
16140  if (typeByteCount > Util.StackAllocationSizeLimit)
16141  {
16142  nativeType = Util.Allocate(typeByteCount + 1);
16143  }
16144  else
16145  {
16146  byte* nativeTypeStackBytes = stackalloc byte[typeByteCount + 1];
16147  nativeType = nativeTypeStackBytes;
16148  }
16149 
16150  int nativeTypeOffset = Util.GetUtf8(type, nativeType, typeByteCount);
16151  nativeType[nativeTypeOffset] = 0;
16152  }
16153  else
16154  {
16155  nativeType = null;
16156  }
16157 
16158  void* nativeData = data.ToPointer();
16159  byte ret = ImGuiNative.igSetDragDropPayload(nativeType, nativeData, sz, cond);
16160  if (typeByteCount > Util.StackAllocationSizeLimit)
16161  {
16162  Util.Free(nativeType);
16163  }
16164 
16165  return ret != 0;
16166  }
16167 
16171  public static void SetItemAllowOverlap()
16172  {
16173  ImGuiNative.igSetItemAllowOverlap();
16174  }
16175 
16179  public static void SetItemDefaultFocus()
16180  {
16181  ImGuiNative.igSetItemDefaultFocus();
16182  }
16183 
16187  public static void SetKeyboardFocusHere()
16188  {
16189  int offset = 0;
16190  ImGuiNative.igSetKeyboardFocusHere(offset);
16191  }
16192 
16197  public static void SetKeyboardFocusHere(int offset)
16198  {
16199  ImGuiNative.igSetKeyboardFocusHere(offset);
16200  }
16201 
16206  public static void SetMouseCursor(ImGuiMouseCursor cursorType)
16207  {
16208  ImGuiNative.igSetMouseCursor(cursorType);
16209  }
16210 
16215  public static void SetNextFrameWantCaptureKeyboard(bool wantCaptureKeyboard)
16216  {
16217  byte nativeWantCaptureKeyboard = wantCaptureKeyboard ? (byte) 1 : (byte) 0;
16218  ImGuiNative.igSetNextFrameWantCaptureKeyboard(nativeWantCaptureKeyboard);
16219  }
16220 
16225  public static void SetNextFrameWantCaptureMouse(bool wantCaptureMouse)
16226  {
16227  byte nativeWantCaptureMouse = wantCaptureMouse ? (byte) 1 : (byte) 0;
16228  ImGuiNative.igSetNextFrameWantCaptureMouse(nativeWantCaptureMouse);
16229  }
16230 
16235  public static void SetNextItemOpen(bool isOpen)
16236  {
16237  byte nativeIsOpen = isOpen ? (byte) 1 : (byte) 0;
16238  ImGuiCond cond = 0;
16239  ImGuiNative.igSetNextItemOpen(nativeIsOpen, cond);
16240  }
16241 
16247  public static void SetNextItemOpen(bool isOpen, ImGuiCond cond)
16248  {
16249  byte nativeIsOpen = isOpen ? (byte) 1 : (byte) 0;
16250  ImGuiNative.igSetNextItemOpen(nativeIsOpen, cond);
16251  }
16252 
16257  public static void SetNextItemWidth(float itemWidth)
16258  {
16259  ImGuiNative.igSetNextItemWidth(itemWidth);
16260  }
16261 
16266  public static void SetNextWindowBgAlpha(float alpha)
16267  {
16268  ImGuiNative.igSetNextWindowBgAlpha(alpha);
16269  }
16270 
16275  public static void SetNextWindowClass(ImGuiWindowClassPtr windowClass)
16276  {
16277  ImGuiWindowClass* nativeWindowClass = windowClass.NativePtr;
16278  ImGuiNative.igSetNextWindowClass(nativeWindowClass);
16279  }
16280 
16285  public static void SetNextWindowCollapsed(bool collapsed)
16286  {
16287  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16288  ImGuiCond cond = 0;
16289  ImGuiNative.igSetNextWindowCollapsed(nativeCollapsed, cond);
16290  }
16291 
16297  public static void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
16298  {
16299  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16300  ImGuiNative.igSetNextWindowCollapsed(nativeCollapsed, cond);
16301  }
16302 
16307  public static void SetNextWindowContentSize(Vector2F size)
16308  {
16309  ImGuiNative.igSetNextWindowContentSize(size);
16310  }
16311 
16316  public static void SetNextWindowDockId(uint dockId)
16317  {
16318  ImGuiCond cond = 0;
16319  ImGuiNative.igSetNextWindowDockID(dockId, cond);
16320  }
16321 
16327  public static void SetNextWindowDockId(uint dockId, ImGuiCond cond)
16328  {
16329  ImGuiNative.igSetNextWindowDockID(dockId, cond);
16330  }
16331 
16335  public static void SetNextWindowFocus()
16336  {
16337  ImGuiNative.igSetNextWindowFocus();
16338  }
16339 
16344  public static void SetNextWindowPos(Vector2F pos)
16345  {
16346  ImGuiCond cond = 0;
16347  Vector2F pivot = new Vector2F();
16348  ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
16349  }
16350 
16356  public static void SetNextWindowPos(Vector2F pos, ImGuiCond cond)
16357  {
16358  Vector2F pivot = new Vector2F();
16359  ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
16360  }
16361 
16368  public static void SetNextWindowPos(Vector2F pos, ImGuiCond cond, Vector2F pivot)
16369  {
16370  ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
16371  }
16372 
16377  public static void SetNextWindowScroll(Vector2F scroll)
16378  {
16379  ImGuiNative.igSetNextWindowScroll(scroll);
16380  }
16381 
16386  public static void SetNextWindowSize(Vector2F size)
16387  {
16388  ImGuiCond cond = 0;
16389  ImGuiNative.igSetNextWindowSize(size, cond);
16390  }
16391 
16397  public static void SetNextWindowSize(Vector2F size, ImGuiCond cond)
16398  {
16399  ImGuiNative.igSetNextWindowSize(size, cond);
16400  }
16401 
16407  public static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax)
16408  {
16409  ImGuiSizeCallback customCallback = null;
16410  void* customCallbackData = null;
16411  ImGuiNative.igSetNextWindowSizeConstraints(sizeMin, sizeMax, customCallback, customCallbackData);
16412  }
16413 
16420  public static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback)
16421  {
16422  void* customCallbackData = null;
16423  ImGuiNative.igSetNextWindowSizeConstraints(sizeMin, sizeMax, customCallback, customCallbackData);
16424  }
16425 
16433  public static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback, IntPtr customCallbackData)
16434  {
16435  void* nativeCustomCallbackData = customCallbackData.ToPointer();
16436  ImGuiNative.igSetNextWindowSizeConstraints(sizeMin, sizeMax, customCallback, nativeCustomCallbackData);
16437  }
16438 
16443  public static void SetNextWindowViewport(uint viewportId)
16444  {
16445  ImGuiNative.igSetNextWindowViewport(viewportId);
16446  }
16447 
16452  public static void SetScrollFromPosX(float localX)
16453  {
16454  float centerXRatio = 0.5f;
16455  ImGuiNative.igSetScrollFromPosX_Float(localX, centerXRatio);
16456  }
16457 
16463  public static void SetScrollFromPosX(float localX, float centerXRatio)
16464  {
16465  ImGuiNative.igSetScrollFromPosX_Float(localX, centerXRatio);
16466  }
16467 
16472  public static void SetScrollFromPosY(float localY)
16473  {
16474  float centerYRatio = 0.5f;
16475  ImGuiNative.igSetScrollFromPosY_Float(localY, centerYRatio);
16476  }
16477 
16483  public static void SetScrollFromPosY(float localY, float centerYRatio)
16484  {
16485  ImGuiNative.igSetScrollFromPosY_Float(localY, centerYRatio);
16486  }
16487 
16491  public static void SetScrollHereX()
16492  {
16493  float centerXRatio = 0.5f;
16494  ImGuiNative.igSetScrollHereX(centerXRatio);
16495  }
16496 
16501  public static void SetScrollHereX(float centerXRatio)
16502  {
16503  ImGuiNative.igSetScrollHereX(centerXRatio);
16504  }
16505 
16509  public static void SetScrollHereY()
16510  {
16511  float centerYRatio = 0.5f;
16512  ImGuiNative.igSetScrollHereY(centerYRatio);
16513  }
16514 
16519  public static void SetScrollHereY(float centerYRatio)
16520  {
16521  ImGuiNative.igSetScrollHereY(centerYRatio);
16522  }
16523 
16528  public static void SetScrollX(float scrollX)
16529  {
16530  ImGuiNative.igSetScrollX_Float(scrollX);
16531  }
16532 
16537  public static void SetScrollY(float scrollY)
16538  {
16539  ImGuiNative.igSetScrollY_Float(scrollY);
16540  }
16541 
16546  public static void SetStateStorage(ImGuiStoragePtr storage)
16547  {
16548  ImGuiStorage* nativeStorage = storage.NativePtr;
16549  ImGuiNative.igSetStateStorage(nativeStorage);
16550  }
16551 
16556  public static void SetTabItemClosed(string tabOrDockedWindowLabel)
16557  {
16558  byte* nativeTabOrDockedWindowLabel;
16559  int tabOrDockedWindowLabelByteCount = 0;
16560  if (tabOrDockedWindowLabel != null)
16561  {
16562  tabOrDockedWindowLabelByteCount = Encoding.UTF8.GetByteCount(tabOrDockedWindowLabel);
16563  if (tabOrDockedWindowLabelByteCount > Util.StackAllocationSizeLimit)
16564  {
16565  nativeTabOrDockedWindowLabel = Util.Allocate(tabOrDockedWindowLabelByteCount + 1);
16566  }
16567  else
16568  {
16569  byte* nativeTabOrDockedWindowLabelStackBytes = stackalloc byte[tabOrDockedWindowLabelByteCount + 1];
16570  nativeTabOrDockedWindowLabel = nativeTabOrDockedWindowLabelStackBytes;
16571  }
16572 
16573  int nativeTabOrDockedWindowLabelOffset = Util.GetUtf8(tabOrDockedWindowLabel, nativeTabOrDockedWindowLabel, tabOrDockedWindowLabelByteCount);
16574  nativeTabOrDockedWindowLabel[nativeTabOrDockedWindowLabelOffset] = 0;
16575  }
16576  else
16577  {
16578  nativeTabOrDockedWindowLabel = null;
16579  }
16580 
16581  ImGuiNative.igSetTabItemClosed(nativeTabOrDockedWindowLabel);
16582  if (tabOrDockedWindowLabelByteCount > Util.StackAllocationSizeLimit)
16583  {
16584  Util.Free(nativeTabOrDockedWindowLabel);
16585  }
16586  }
16587 
16592  public static void SetTooltip(string fmt)
16593  {
16594  byte* nativeFmt;
16595  int fmtByteCount = 0;
16596  if (fmt != null)
16597  {
16598  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
16599  if (fmtByteCount > Util.StackAllocationSizeLimit)
16600  {
16601  nativeFmt = Util.Allocate(fmtByteCount + 1);
16602  }
16603  else
16604  {
16605  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
16606  nativeFmt = nativeFmtStackBytes;
16607  }
16608 
16609  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
16610  nativeFmt[nativeFmtOffset] = 0;
16611  }
16612  else
16613  {
16614  nativeFmt = null;
16615  }
16616 
16617  ImGuiNative.igSetTooltip(nativeFmt);
16618  if (fmtByteCount > Util.StackAllocationSizeLimit)
16619  {
16620  Util.Free(nativeFmt);
16621  }
16622  }
16623 
16628  public static void SetWindowCollapsed(bool collapsed)
16629  {
16630  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16631  ImGuiCond cond = 0;
16632  ImGuiNative.igSetWindowCollapsed_Bool(nativeCollapsed, cond);
16633  }
16634 
16640  public static void SetWindowCollapsed(bool collapsed, ImGuiCond cond)
16641  {
16642  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16643  ImGuiNative.igSetWindowCollapsed_Bool(nativeCollapsed, cond);
16644  }
16645 
16651  public static void SetWindowCollapsed(string name, bool collapsed)
16652  {
16653  byte* nativeName;
16654  int nameByteCount = 0;
16655  if (name != null)
16656  {
16657  nameByteCount = Encoding.UTF8.GetByteCount(name);
16658  if (nameByteCount > Util.StackAllocationSizeLimit)
16659  {
16660  nativeName = Util.Allocate(nameByteCount + 1);
16661  }
16662  else
16663  {
16664  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16665  nativeName = nativeNameStackBytes;
16666  }
16667 
16668  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16669  nativeName[nativeNameOffset] = 0;
16670  }
16671  else
16672  {
16673  nativeName = null;
16674  }
16675 
16676  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16677  ImGuiCond cond = 0;
16678  ImGuiNative.igSetWindowCollapsed_Str(nativeName, nativeCollapsed, cond);
16679  if (nameByteCount > Util.StackAllocationSizeLimit)
16680  {
16681  Util.Free(nativeName);
16682  }
16683  }
16684 
16691  public static void SetWindowCollapsed(string name, bool collapsed, ImGuiCond cond)
16692  {
16693  byte* nativeName;
16694  int nameByteCount = 0;
16695  if (name != null)
16696  {
16697  nameByteCount = Encoding.UTF8.GetByteCount(name);
16698  if (nameByteCount > Util.StackAllocationSizeLimit)
16699  {
16700  nativeName = Util.Allocate(nameByteCount + 1);
16701  }
16702  else
16703  {
16704  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16705  nativeName = nativeNameStackBytes;
16706  }
16707 
16708  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16709  nativeName[nativeNameOffset] = 0;
16710  }
16711  else
16712  {
16713  nativeName = null;
16714  }
16715 
16716  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16717  ImGuiNative.igSetWindowCollapsed_Str(nativeName, nativeCollapsed, cond);
16718  if (nameByteCount > Util.StackAllocationSizeLimit)
16719  {
16720  Util.Free(nativeName);
16721  }
16722  }
16723 
16727  public static void SetWindowFocus()
16728  {
16729  ImGuiNative.igSetWindowFocus_Nil();
16730  }
16731 
16736  public static void SetWindowFocus(string name)
16737  {
16738  byte* nativeName;
16739  int nameByteCount = 0;
16740  if (name != null)
16741  {
16742  nameByteCount = Encoding.UTF8.GetByteCount(name);
16743  if (nameByteCount > Util.StackAllocationSizeLimit)
16744  {
16745  nativeName = Util.Allocate(nameByteCount + 1);
16746  }
16747  else
16748  {
16749  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16750  nativeName = nativeNameStackBytes;
16751  }
16752 
16753  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16754  nativeName[nativeNameOffset] = 0;
16755  }
16756  else
16757  {
16758  nativeName = null;
16759  }
16760 
16761  ImGuiNative.igSetWindowFocus_Str(nativeName);
16762  if (nameByteCount > Util.StackAllocationSizeLimit)
16763  {
16764  Util.Free(nativeName);
16765  }
16766  }
16767 
16772  public static void SetWindowFontScale(float scale)
16773  {
16774  ImGuiNative.igSetWindowFontScale(scale);
16775  }
16776 
16781  public static void SetWindowPos(Vector2F pos)
16782  {
16783  ImGuiCond cond = 0;
16784  ImGuiNative.igSetWindowPos_Vec2(pos, cond);
16785  }
16786 
16792  public static void SetWindowPos(Vector2F pos, ImGuiCond cond)
16793  {
16794  ImGuiNative.igSetWindowPos_Vec2(pos, cond);
16795  }
16796 
16802  public static void SetWindowPos(string name, Vector2F pos)
16803  {
16804  byte* nativeName;
16805  int nameByteCount = 0;
16806  if (name != null)
16807  {
16808  nameByteCount = Encoding.UTF8.GetByteCount(name);
16809  if (nameByteCount > Util.StackAllocationSizeLimit)
16810  {
16811  nativeName = Util.Allocate(nameByteCount + 1);
16812  }
16813  else
16814  {
16815  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16816  nativeName = nativeNameStackBytes;
16817  }
16818 
16819  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16820  nativeName[nativeNameOffset] = 0;
16821  }
16822  else
16823  {
16824  nativeName = null;
16825  }
16826 
16827  ImGuiCond cond = 0;
16828  ImGuiNative.igSetWindowPos_Str(nativeName, pos, cond);
16829  if (nameByteCount > Util.StackAllocationSizeLimit)
16830  {
16831  Util.Free(nativeName);
16832  }
16833  }
16834 
16841  public static void SetWindowPos(string name, Vector2F pos, ImGuiCond cond)
16842  {
16843  byte* nativeName;
16844  int nameByteCount = 0;
16845  if (name != null)
16846  {
16847  nameByteCount = Encoding.UTF8.GetByteCount(name);
16848  if (nameByteCount > Util.StackAllocationSizeLimit)
16849  {
16850  nativeName = Util.Allocate(nameByteCount + 1);
16851  }
16852  else
16853  {
16854  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16855  nativeName = nativeNameStackBytes;
16856  }
16857 
16858  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16859  nativeName[nativeNameOffset] = 0;
16860  }
16861  else
16862  {
16863  nativeName = null;
16864  }
16865 
16866  ImGuiNative.igSetWindowPos_Str(nativeName, pos, cond);
16867  if (nameByteCount > Util.StackAllocationSizeLimit)
16868  {
16869  Util.Free(nativeName);
16870  }
16871  }
16872 
16877  public static void SetWindowSize(Vector2F size)
16878  {
16879  ImGuiCond cond = 0;
16880  ImGuiNative.igSetWindowSize_Vec2(size, cond);
16881  }
16882 
16888  public static void SetWindowSize(Vector2F size, ImGuiCond cond)
16889  {
16890  ImGuiNative.igSetWindowSize_Vec2(size, cond);
16891  }
16892 
16898  public static void SetWindowSize(string name, Vector2F size)
16899  {
16900  byte* nativeName;
16901  int nameByteCount = 0;
16902  if (name != null)
16903  {
16904  nameByteCount = Encoding.UTF8.GetByteCount(name);
16905  if (nameByteCount > Util.StackAllocationSizeLimit)
16906  {
16907  nativeName = Util.Allocate(nameByteCount + 1);
16908  }
16909  else
16910  {
16911  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16912  nativeName = nativeNameStackBytes;
16913  }
16914 
16915  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16916  nativeName[nativeNameOffset] = 0;
16917  }
16918  else
16919  {
16920  nativeName = null;
16921  }
16922 
16923  ImGuiCond cond = 0;
16924  ImGuiNative.igSetWindowSize_Str(nativeName, size, cond);
16925  if (nameByteCount > Util.StackAllocationSizeLimit)
16926  {
16927  Util.Free(nativeName);
16928  }
16929  }
16930 
16937  public static void SetWindowSize(string name, Vector2F size, ImGuiCond cond)
16938  {
16939  byte* nativeName;
16940  int nameByteCount = 0;
16941  if (name != null)
16942  {
16943  nameByteCount = Encoding.UTF8.GetByteCount(name);
16944  if (nameByteCount > Util.StackAllocationSizeLimit)
16945  {
16946  nativeName = Util.Allocate(nameByteCount + 1);
16947  }
16948  else
16949  {
16950  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16951  nativeName = nativeNameStackBytes;
16952  }
16953 
16954  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16955  nativeName[nativeNameOffset] = 0;
16956  }
16957  else
16958  {
16959  nativeName = null;
16960  }
16961 
16962  ImGuiNative.igSetWindowSize_Str(nativeName, size, cond);
16963  if (nameByteCount > Util.StackAllocationSizeLimit)
16964  {
16965  Util.Free(nativeName);
16966  }
16967  }
16968 
16972  public static void ShowAboutWindow()
16973  {
16974  byte* pOpen = null;
16975  ImGuiNative.igShowAboutWindow(pOpen);
16976  }
16977 
16982  public static void ShowAboutWindow(ref bool pOpen)
16983  {
16984  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
16985  byte* nativePOpen = &nativePOpenVal;
16986  ImGuiNative.igShowAboutWindow(nativePOpen);
16987  pOpen = nativePOpenVal != 0;
16988  }
16989 
16993  public static void ShowDebugLogWindow()
16994  {
16995  byte* pOpen = null;
16996  ImGuiNative.igShowDebugLogWindow(pOpen);
16997  }
16998 
17003  public static void ShowDebugLogWindow(ref bool pOpen)
17004  {
17005  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
17006  byte* nativePOpen = &nativePOpenVal;
17007  ImGuiNative.igShowDebugLogWindow(nativePOpen);
17008  pOpen = nativePOpenVal != 0;
17009  }
17010 
17014  public static void ShowDemoWindow()
17015  {
17016  byte* pOpen = null;
17017  ImGuiNative.igShowDemoWindow(pOpen);
17018  }
17019 
17024  public static void ShowDemoWindow(ref bool pOpen)
17025  {
17026  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
17027  byte* nativePOpen = &nativePOpenVal;
17028  ImGuiNative.igShowDemoWindow(nativePOpen);
17029  pOpen = nativePOpenVal != 0;
17030  }
17031 
17036  public static void ShowFontSelector(string label)
17037  {
17038  byte* nativeLabel;
17039  int labelByteCount = 0;
17040  if (label != null)
17041  {
17042  labelByteCount = Encoding.UTF8.GetByteCount(label);
17043  if (labelByteCount > Util.StackAllocationSizeLimit)
17044  {
17045  nativeLabel = Util.Allocate(labelByteCount + 1);
17046  }
17047  else
17048  {
17049  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17050  nativeLabel = nativeLabelStackBytes;
17051  }
17052 
17053  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17054  nativeLabel[nativeLabelOffset] = 0;
17055  }
17056  else
17057  {
17058  nativeLabel = null;
17059  }
17060 
17061  ImGuiNative.igShowFontSelector(nativeLabel);
17062  if (labelByteCount > Util.StackAllocationSizeLimit)
17063  {
17064  Util.Free(nativeLabel);
17065  }
17066  }
17067 
17071  public static void ShowMetricsWindow()
17072  {
17073  byte* pOpen = null;
17074  ImGuiNative.igShowMetricsWindow(pOpen);
17075  }
17076 
17081  public static void ShowMetricsWindow(ref bool pOpen)
17082  {
17083  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
17084  byte* nativePOpen = &nativePOpenVal;
17085  ImGuiNative.igShowMetricsWindow(nativePOpen);
17086  pOpen = nativePOpenVal != 0;
17087  }
17088 
17092  public static void ShowStackToolWindow()
17093  {
17094  byte* pOpen = null;
17095  ImGuiNative.igShowStackToolWindow(pOpen);
17096  }
17097 
17102  public static void ShowStackToolWindow(ref bool pOpen)
17103  {
17104  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
17105  byte* nativePOpen = &nativePOpenVal;
17106  ImGuiNative.igShowStackToolWindow(nativePOpen);
17107  pOpen = nativePOpenVal != 0;
17108  }
17109 
17113  public static void ShowStyleEditor()
17114  {
17115  ImGuiStyle* @ref = null;
17116  ImGuiNative.igShowStyleEditor(@ref);
17117  }
17118 
17122  public static void ShowStyleEditor(ImGuiStylePtr @ref)
17123  {
17124  ImGuiStyle* nativeRef = @ref.NativePtr;
17125  ImGuiNative.igShowStyleEditor(nativeRef);
17126  }
17127 
17133  public static bool ShowStyleSelector(string label)
17134  {
17135  byte* nativeLabel;
17136  int labelByteCount = 0;
17137  if (label != null)
17138  {
17139  labelByteCount = Encoding.UTF8.GetByteCount(label);
17140  if (labelByteCount > Util.StackAllocationSizeLimit)
17141  {
17142  nativeLabel = Util.Allocate(labelByteCount + 1);
17143  }
17144  else
17145  {
17146  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17147  nativeLabel = nativeLabelStackBytes;
17148  }
17149 
17150  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17151  nativeLabel[nativeLabelOffset] = 0;
17152  }
17153  else
17154  {
17155  nativeLabel = null;
17156  }
17157 
17158  byte ret = ImGuiNative.igShowStyleSelector(nativeLabel);
17159  if (labelByteCount > Util.StackAllocationSizeLimit)
17160  {
17161  Util.Free(nativeLabel);
17162  }
17163 
17164  return ret != 0;
17165  }
17166 
17170  public static void ShowUserGuide()
17171  {
17172  ImGuiNative.igShowUserGuide();
17173  }
17174 
17181  public static bool SliderAngle(string label, ref float vRad)
17182  {
17183  byte* nativeLabel;
17184  int labelByteCount = 0;
17185  if (label != null)
17186  {
17187  labelByteCount = Encoding.UTF8.GetByteCount(label);
17188  if (labelByteCount > Util.StackAllocationSizeLimit)
17189  {
17190  nativeLabel = Util.Allocate(labelByteCount + 1);
17191  }
17192  else
17193  {
17194  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17195  nativeLabel = nativeLabelStackBytes;
17196  }
17197 
17198  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17199  nativeLabel[nativeLabelOffset] = 0;
17200  }
17201  else
17202  {
17203  nativeLabel = null;
17204  }
17205 
17206  float vDegreesMin = -360.0f;
17207  float vDegreesMax = +360.0f;
17208  byte* nativeFormat;
17209  int formatByteCount = 0;
17210  formatByteCount = Encoding.UTF8.GetByteCount("%.0f deg");
17211  if (formatByteCount > Util.StackAllocationSizeLimit)
17212  {
17213  nativeFormat = Util.Allocate(formatByteCount + 1);
17214  }
17215  else
17216  {
17217  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17218  nativeFormat = nativeFormatStackBytes;
17219  }
17220 
17221  int nativeFormatOffset = Util.GetUtf8("%.0f deg", nativeFormat, formatByteCount);
17222  nativeFormat[nativeFormatOffset] = 0;
17223  ImGuiSliderFlags flags = 0;
17224  fixed (float* nativeVRad = &vRad)
17225  {
17226  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flags);
17227  if (labelByteCount > Util.StackAllocationSizeLimit)
17228  {
17229  Util.Free(nativeLabel);
17230  }
17231 
17232  if (formatByteCount > Util.StackAllocationSizeLimit)
17233  {
17234  Util.Free(nativeFormat);
17235  }
17236 
17237  return ret != 0;
17238  }
17239  }
17240 
17248  public static bool SliderAngle(string label, ref float vRad, float vDegreesMin)
17249  {
17250  byte* nativeLabel;
17251  int labelByteCount = 0;
17252  if (label != null)
17253  {
17254  labelByteCount = Encoding.UTF8.GetByteCount(label);
17255  if (labelByteCount > Util.StackAllocationSizeLimit)
17256  {
17257  nativeLabel = Util.Allocate(labelByteCount + 1);
17258  }
17259  else
17260  {
17261  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17262  nativeLabel = nativeLabelStackBytes;
17263  }
17264 
17265  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17266  nativeLabel[nativeLabelOffset] = 0;
17267  }
17268  else
17269  {
17270  nativeLabel = null;
17271  }
17272 
17273  float vDegreesMax = +360.0f;
17274  byte* nativeFormat;
17275  int formatByteCount = 0;
17276  formatByteCount = Encoding.UTF8.GetByteCount("%.0f deg");
17277  if (formatByteCount > Util.StackAllocationSizeLimit)
17278  {
17279  nativeFormat = Util.Allocate(formatByteCount + 1);
17280  }
17281  else
17282  {
17283  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17284  nativeFormat = nativeFormatStackBytes;
17285  }
17286 
17287  int nativeFormatOffset = Util.GetUtf8("%.0f deg", nativeFormat, formatByteCount);
17288  nativeFormat[nativeFormatOffset] = 0;
17289  ImGuiSliderFlags flags = 0;
17290  fixed (float* nativeVRad = &vRad)
17291  {
17292  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flags);
17293  if (labelByteCount > Util.StackAllocationSizeLimit)
17294  {
17295  Util.Free(nativeLabel);
17296  }
17297 
17298  if (formatByteCount > Util.StackAllocationSizeLimit)
17299  {
17300  Util.Free(nativeFormat);
17301  }
17302 
17303  return ret != 0;
17304  }
17305  }
17306 
17315  public static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax)
17316  {
17317  byte* nativeLabel;
17318  int labelByteCount = 0;
17319  if (label != null)
17320  {
17321  labelByteCount = Encoding.UTF8.GetByteCount(label);
17322  if (labelByteCount > Util.StackAllocationSizeLimit)
17323  {
17324  nativeLabel = Util.Allocate(labelByteCount + 1);
17325  }
17326  else
17327  {
17328  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17329  nativeLabel = nativeLabelStackBytes;
17330  }
17331 
17332  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17333  nativeLabel[nativeLabelOffset] = 0;
17334  }
17335  else
17336  {
17337  nativeLabel = null;
17338  }
17339 
17340  byte* nativeFormat;
17341  int formatByteCount = 0;
17342  formatByteCount = Encoding.UTF8.GetByteCount("%.0f deg");
17343  if (formatByteCount > Util.StackAllocationSizeLimit)
17344  {
17345  nativeFormat = Util.Allocate(formatByteCount + 1);
17346  }
17347  else
17348  {
17349  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17350  nativeFormat = nativeFormatStackBytes;
17351  }
17352 
17353  int nativeFormatOffset = Util.GetUtf8("%.0f deg", nativeFormat, formatByteCount);
17354  nativeFormat[nativeFormatOffset] = 0;
17355  ImGuiSliderFlags flags = 0;
17356  fixed (float* nativeVRad = &vRad)
17357  {
17358  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flags);
17359  if (labelByteCount > Util.StackAllocationSizeLimit)
17360  {
17361  Util.Free(nativeLabel);
17362  }
17363 
17364  if (formatByteCount > Util.StackAllocationSizeLimit)
17365  {
17366  Util.Free(nativeFormat);
17367  }
17368 
17369  return ret != 0;
17370  }
17371  }
17372 
17382  public static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax, string format)
17383  {
17384  byte* nativeLabel;
17385  int labelByteCount = 0;
17386  if (label != null)
17387  {
17388  labelByteCount = Encoding.UTF8.GetByteCount(label);
17389  if (labelByteCount > Util.StackAllocationSizeLimit)
17390  {
17391  nativeLabel = Util.Allocate(labelByteCount + 1);
17392  }
17393  else
17394  {
17395  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17396  nativeLabel = nativeLabelStackBytes;
17397  }
17398 
17399  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17400  nativeLabel[nativeLabelOffset] = 0;
17401  }
17402  else
17403  {
17404  nativeLabel = null;
17405  }
17406 
17407  byte* nativeFormat;
17408  int formatByteCount = 0;
17409  if (format != null)
17410  {
17411  formatByteCount = Encoding.UTF8.GetByteCount(format);
17412  if (formatByteCount > Util.StackAllocationSizeLimit)
17413  {
17414  nativeFormat = Util.Allocate(formatByteCount + 1);
17415  }
17416  else
17417  {
17418  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17419  nativeFormat = nativeFormatStackBytes;
17420  }
17421 
17422  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17423  nativeFormat[nativeFormatOffset] = 0;
17424  }
17425  else
17426  {
17427  nativeFormat = null;
17428  }
17429 
17430  ImGuiSliderFlags flags = 0;
17431  fixed (float* nativeVRad = &vRad)
17432  {
17433  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flags);
17434  if (labelByteCount > Util.StackAllocationSizeLimit)
17435  {
17436  Util.Free(nativeLabel);
17437  }
17438 
17439  if (formatByteCount > Util.StackAllocationSizeLimit)
17440  {
17441  Util.Free(nativeFormat);
17442  }
17443 
17444  return ret != 0;
17445  }
17446  }
17447 
17458  public static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax, string format, ImGuiSliderFlags flags)
17459  {
17460  byte* nativeLabel;
17461  int labelByteCount = 0;
17462  if (label != null)
17463  {
17464  labelByteCount = Encoding.UTF8.GetByteCount(label);
17465  if (labelByteCount > Util.StackAllocationSizeLimit)
17466  {
17467  nativeLabel = Util.Allocate(labelByteCount + 1);
17468  }
17469  else
17470  {
17471  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17472  nativeLabel = nativeLabelStackBytes;
17473  }
17474 
17475  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17476  nativeLabel[nativeLabelOffset] = 0;
17477  }
17478  else
17479  {
17480  nativeLabel = null;
17481  }
17482 
17483  byte* nativeFormat;
17484  int formatByteCount = 0;
17485  if (format != null)
17486  {
17487  formatByteCount = Encoding.UTF8.GetByteCount(format);
17488  if (formatByteCount > Util.StackAllocationSizeLimit)
17489  {
17490  nativeFormat = Util.Allocate(formatByteCount + 1);
17491  }
17492  else
17493  {
17494  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17495  nativeFormat = nativeFormatStackBytes;
17496  }
17497 
17498  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17499  nativeFormat[nativeFormatOffset] = 0;
17500  }
17501  else
17502  {
17503  nativeFormat = null;
17504  }
17505 
17506  fixed (float* nativeVRad = &vRad)
17507  {
17508  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flags);
17509  if (labelByteCount > Util.StackAllocationSizeLimit)
17510  {
17511  Util.Free(nativeLabel);
17512  }
17513 
17514  if (formatByteCount > Util.StackAllocationSizeLimit)
17515  {
17516  Util.Free(nativeFormat);
17517  }
17518 
17519  return ret != 0;
17520  }
17521  }
17522 
17531  public static bool SliderFloat(string label, ref float v, float vMin, float vMax)
17532  {
17533  byte* nativeLabel;
17534  int labelByteCount = 0;
17535  if (label != null)
17536  {
17537  labelByteCount = Encoding.UTF8.GetByteCount(label);
17538  if (labelByteCount > Util.StackAllocationSizeLimit)
17539  {
17540  nativeLabel = Util.Allocate(labelByteCount + 1);
17541  }
17542  else
17543  {
17544  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17545  nativeLabel = nativeLabelStackBytes;
17546  }
17547 
17548  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17549  nativeLabel[nativeLabelOffset] = 0;
17550  }
17551  else
17552  {
17553  nativeLabel = null;
17554  }
17555 
17556  byte* nativeFormat;
17557  int formatByteCount = 0;
17558  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
17559  if (formatByteCount > Util.StackAllocationSizeLimit)
17560  {
17561  nativeFormat = Util.Allocate(formatByteCount + 1);
17562  }
17563  else
17564  {
17565  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17566  nativeFormat = nativeFormatStackBytes;
17567  }
17568 
17569  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
17570  nativeFormat[nativeFormatOffset] = 0;
17571  ImGuiSliderFlags flags = 0;
17572  fixed (float* nativeV = &v)
17573  {
17574  byte ret = ImGuiNative.igSliderFloat(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
17575  if (labelByteCount > Util.StackAllocationSizeLimit)
17576  {
17577  Util.Free(nativeLabel);
17578  }
17579 
17580  if (formatByteCount > Util.StackAllocationSizeLimit)
17581  {
17582  Util.Free(nativeFormat);
17583  }
17584 
17585  return ret != 0;
17586  }
17587  }
17588 
17598  public static bool SliderFloat(string label, ref float v, float vMin, float vMax, string format)
17599  {
17600  byte* nativeLabel;
17601  int labelByteCount = 0;
17602  if (label != null)
17603  {
17604  labelByteCount = Encoding.UTF8.GetByteCount(label);
17605  if (labelByteCount > Util.StackAllocationSizeLimit)
17606  {
17607  nativeLabel = Util.Allocate(labelByteCount + 1);
17608  }
17609  else
17610  {
17611  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17612  nativeLabel = nativeLabelStackBytes;
17613  }
17614 
17615  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17616  nativeLabel[nativeLabelOffset] = 0;
17617  }
17618  else
17619  {
17620  nativeLabel = null;
17621  }
17622 
17623  byte* nativeFormat;
17624  int formatByteCount = 0;
17625  if (format != null)
17626  {
17627  formatByteCount = Encoding.UTF8.GetByteCount(format);
17628  if (formatByteCount > Util.StackAllocationSizeLimit)
17629  {
17630  nativeFormat = Util.Allocate(formatByteCount + 1);
17631  }
17632  else
17633  {
17634  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17635  nativeFormat = nativeFormatStackBytes;
17636  }
17637 
17638  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17639  nativeFormat[nativeFormatOffset] = 0;
17640  }
17641  else
17642  {
17643  nativeFormat = null;
17644  }
17645 
17646  ImGuiSliderFlags flags = 0;
17647  fixed (float* nativeV = &v)
17648  {
17649  byte ret = ImGuiNative.igSliderFloat(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
17650  if (labelByteCount > Util.StackAllocationSizeLimit)
17651  {
17652  Util.Free(nativeLabel);
17653  }
17654 
17655  if (formatByteCount > Util.StackAllocationSizeLimit)
17656  {
17657  Util.Free(nativeFormat);
17658  }
17659 
17660  return ret != 0;
17661  }
17662  }
17663 
17674  public static bool SliderFloat(string label, ref float v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
17675  {
17676  byte* nativeLabel;
17677  int labelByteCount = 0;
17678  if (label != null)
17679  {
17680  labelByteCount = Encoding.UTF8.GetByteCount(label);
17681  if (labelByteCount > Util.StackAllocationSizeLimit)
17682  {
17683  nativeLabel = Util.Allocate(labelByteCount + 1);
17684  }
17685  else
17686  {
17687  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17688  nativeLabel = nativeLabelStackBytes;
17689  }
17690 
17691  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17692  nativeLabel[nativeLabelOffset] = 0;
17693  }
17694  else
17695  {
17696  nativeLabel = null;
17697  }
17698 
17699  byte* nativeFormat;
17700  int formatByteCount = 0;
17701  if (format != null)
17702  {
17703  formatByteCount = Encoding.UTF8.GetByteCount(format);
17704  if (formatByteCount > Util.StackAllocationSizeLimit)
17705  {
17706  nativeFormat = Util.Allocate(formatByteCount + 1);
17707  }
17708  else
17709  {
17710  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17711  nativeFormat = nativeFormatStackBytes;
17712  }
17713 
17714  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17715  nativeFormat[nativeFormatOffset] = 0;
17716  }
17717  else
17718  {
17719  nativeFormat = null;
17720  }
17721 
17722  fixed (float* nativeV = &v)
17723  {
17724  byte ret = ImGuiNative.igSliderFloat(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
17725  if (labelByteCount > Util.StackAllocationSizeLimit)
17726  {
17727  Util.Free(nativeLabel);
17728  }
17729 
17730  if (formatByteCount > Util.StackAllocationSizeLimit)
17731  {
17732  Util.Free(nativeFormat);
17733  }
17734 
17735  return ret != 0;
17736  }
17737  }
17738 
17747  public static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax)
17748  {
17749  byte* nativeLabel;
17750  int labelByteCount = 0;
17751  if (label != null)
17752  {
17753  labelByteCount = Encoding.UTF8.GetByteCount(label);
17754  if (labelByteCount > Util.StackAllocationSizeLimit)
17755  {
17756  nativeLabel = Util.Allocate(labelByteCount + 1);
17757  }
17758  else
17759  {
17760  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17761  nativeLabel = nativeLabelStackBytes;
17762  }
17763 
17764  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17765  nativeLabel[nativeLabelOffset] = 0;
17766  }
17767  else
17768  {
17769  nativeLabel = null;
17770  }
17771 
17772  byte* nativeFormat;
17773  int formatByteCount = 0;
17774  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
17775  if (formatByteCount > Util.StackAllocationSizeLimit)
17776  {
17777  nativeFormat = Util.Allocate(formatByteCount + 1);
17778  }
17779  else
17780  {
17781  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17782  nativeFormat = nativeFormatStackBytes;
17783  }
17784 
17785  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
17786  nativeFormat[nativeFormatOffset] = 0;
17787  ImGuiSliderFlags flags = 0;
17788  fixed (Vector2F* nativeV = &v)
17789  {
17790  byte ret = ImGuiNative.igSliderFloat2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
17791  if (labelByteCount > Util.StackAllocationSizeLimit)
17792  {
17793  Util.Free(nativeLabel);
17794  }
17795 
17796  if (formatByteCount > Util.StackAllocationSizeLimit)
17797  {
17798  Util.Free(nativeFormat);
17799  }
17800 
17801  return ret != 0;
17802  }
17803  }
17804 
17814  public static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax, string format)
17815  {
17816  byte* nativeLabel;
17817  int labelByteCount = 0;
17818  if (label != null)
17819  {
17820  labelByteCount = Encoding.UTF8.GetByteCount(label);
17821  if (labelByteCount > Util.StackAllocationSizeLimit)
17822  {
17823  nativeLabel = Util.Allocate(labelByteCount + 1);
17824  }
17825  else
17826  {
17827  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17828  nativeLabel = nativeLabelStackBytes;
17829  }
17830 
17831  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17832  nativeLabel[nativeLabelOffset] = 0;
17833  }
17834  else
17835  {
17836  nativeLabel = null;
17837  }
17838 
17839  byte* nativeFormat;
17840  int formatByteCount = 0;
17841  if (format != null)
17842  {
17843  formatByteCount = Encoding.UTF8.GetByteCount(format);
17844  if (formatByteCount > Util.StackAllocationSizeLimit)
17845  {
17846  nativeFormat = Util.Allocate(formatByteCount + 1);
17847  }
17848  else
17849  {
17850  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17851  nativeFormat = nativeFormatStackBytes;
17852  }
17853 
17854  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17855  nativeFormat[nativeFormatOffset] = 0;
17856  }
17857  else
17858  {
17859  nativeFormat = null;
17860  }
17861 
17862  ImGuiSliderFlags flags = 0;
17863  fixed (Vector2F* nativeV = &v)
17864  {
17865  byte ret = ImGuiNative.igSliderFloat2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
17866  if (labelByteCount > Util.StackAllocationSizeLimit)
17867  {
17868  Util.Free(nativeLabel);
17869  }
17870 
17871  if (formatByteCount > Util.StackAllocationSizeLimit)
17872  {
17873  Util.Free(nativeFormat);
17874  }
17875 
17876  return ret != 0;
17877  }
17878  }
17879 
17890  public static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
17891  {
17892  byte* nativeLabel;
17893  int labelByteCount = 0;
17894  if (label != null)
17895  {
17896  labelByteCount = Encoding.UTF8.GetByteCount(label);
17897  if (labelByteCount > Util.StackAllocationSizeLimit)
17898  {
17899  nativeLabel = Util.Allocate(labelByteCount + 1);
17900  }
17901  else
17902  {
17903  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17904  nativeLabel = nativeLabelStackBytes;
17905  }
17906 
17907  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17908  nativeLabel[nativeLabelOffset] = 0;
17909  }
17910  else
17911  {
17912  nativeLabel = null;
17913  }
17914 
17915  byte* nativeFormat;
17916  int formatByteCount = 0;
17917  if (format != null)
17918  {
17919  formatByteCount = Encoding.UTF8.GetByteCount(format);
17920  if (formatByteCount > Util.StackAllocationSizeLimit)
17921  {
17922  nativeFormat = Util.Allocate(formatByteCount + 1);
17923  }
17924  else
17925  {
17926  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17927  nativeFormat = nativeFormatStackBytes;
17928  }
17929 
17930  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17931  nativeFormat[nativeFormatOffset] = 0;
17932  }
17933  else
17934  {
17935  nativeFormat = null;
17936  }
17937 
17938  fixed (Vector2F* nativeV = &v)
17939  {
17940  byte ret = ImGuiNative.igSliderFloat2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
17941  if (labelByteCount > Util.StackAllocationSizeLimit)
17942  {
17943  Util.Free(nativeLabel);
17944  }
17945 
17946  if (formatByteCount > Util.StackAllocationSizeLimit)
17947  {
17948  Util.Free(nativeFormat);
17949  }
17950 
17951  return ret != 0;
17952  }
17953  }
17954 
17963  public static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax)
17964  {
17965  byte* nativeLabel;
17966  int labelByteCount = 0;
17967  if (label != null)
17968  {
17969  labelByteCount = Encoding.UTF8.GetByteCount(label);
17970  if (labelByteCount > Util.StackAllocationSizeLimit)
17971  {
17972  nativeLabel = Util.Allocate(labelByteCount + 1);
17973  }
17974  else
17975  {
17976  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17977  nativeLabel = nativeLabelStackBytes;
17978  }
17979 
17980  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17981  nativeLabel[nativeLabelOffset] = 0;
17982  }
17983  else
17984  {
17985  nativeLabel = null;
17986  }
17987 
17988  byte* nativeFormat;
17989  int formatByteCount = 0;
17990  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
17991  if (formatByteCount > Util.StackAllocationSizeLimit)
17992  {
17993  nativeFormat = Util.Allocate(formatByteCount + 1);
17994  }
17995  else
17996  {
17997  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17998  nativeFormat = nativeFormatStackBytes;
17999  }
18000 
18001  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
18002  nativeFormat[nativeFormatOffset] = 0;
18003  ImGuiSliderFlags flags = 0;
18004  fixed (Vector3F* nativeV = &v)
18005  {
18006  byte ret = ImGuiNative.igSliderFloat3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18007  if (labelByteCount > Util.StackAllocationSizeLimit)
18008  {
18009  Util.Free(nativeLabel);
18010  }
18011 
18012  if (formatByteCount > Util.StackAllocationSizeLimit)
18013  {
18014  Util.Free(nativeFormat);
18015  }
18016 
18017  return ret != 0;
18018  }
18019  }
18020 
18030  public static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax, string format)
18031  {
18032  byte* nativeLabel;
18033  int labelByteCount = 0;
18034  if (label != null)
18035  {
18036  labelByteCount = Encoding.UTF8.GetByteCount(label);
18037  if (labelByteCount > Util.StackAllocationSizeLimit)
18038  {
18039  nativeLabel = Util.Allocate(labelByteCount + 1);
18040  }
18041  else
18042  {
18043  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18044  nativeLabel = nativeLabelStackBytes;
18045  }
18046 
18047  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18048  nativeLabel[nativeLabelOffset] = 0;
18049  }
18050  else
18051  {
18052  nativeLabel = null;
18053  }
18054 
18055  byte* nativeFormat;
18056  int formatByteCount = 0;
18057  if (format != null)
18058  {
18059  formatByteCount = Encoding.UTF8.GetByteCount(format);
18060  if (formatByteCount > Util.StackAllocationSizeLimit)
18061  {
18062  nativeFormat = Util.Allocate(formatByteCount + 1);
18063  }
18064  else
18065  {
18066  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18067  nativeFormat = nativeFormatStackBytes;
18068  }
18069 
18070  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18071  nativeFormat[nativeFormatOffset] = 0;
18072  }
18073  else
18074  {
18075  nativeFormat = null;
18076  }
18077 
18078  ImGuiSliderFlags flags = 0;
18079  fixed (Vector3F* nativeV = &v)
18080  {
18081  byte ret = ImGuiNative.igSliderFloat3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18082  if (labelByteCount > Util.StackAllocationSizeLimit)
18083  {
18084  Util.Free(nativeLabel);
18085  }
18086 
18087  if (formatByteCount > Util.StackAllocationSizeLimit)
18088  {
18089  Util.Free(nativeFormat);
18090  }
18091 
18092  return ret != 0;
18093  }
18094  }
18095 
18106  public static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
18107  {
18108  byte* nativeLabel;
18109  int labelByteCount = 0;
18110  if (label != null)
18111  {
18112  labelByteCount = Encoding.UTF8.GetByteCount(label);
18113  if (labelByteCount > Util.StackAllocationSizeLimit)
18114  {
18115  nativeLabel = Util.Allocate(labelByteCount + 1);
18116  }
18117  else
18118  {
18119  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18120  nativeLabel = nativeLabelStackBytes;
18121  }
18122 
18123  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18124  nativeLabel[nativeLabelOffset] = 0;
18125  }
18126  else
18127  {
18128  nativeLabel = null;
18129  }
18130 
18131  byte* nativeFormat;
18132  int formatByteCount = 0;
18133  if (format != null)
18134  {
18135  formatByteCount = Encoding.UTF8.GetByteCount(format);
18136  if (formatByteCount > Util.StackAllocationSizeLimit)
18137  {
18138  nativeFormat = Util.Allocate(formatByteCount + 1);
18139  }
18140  else
18141  {
18142  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18143  nativeFormat = nativeFormatStackBytes;
18144  }
18145 
18146  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18147  nativeFormat[nativeFormatOffset] = 0;
18148  }
18149  else
18150  {
18151  nativeFormat = null;
18152  }
18153 
18154  fixed (Vector3F* nativeV = &v)
18155  {
18156  byte ret = ImGuiNative.igSliderFloat3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18157  if (labelByteCount > Util.StackAllocationSizeLimit)
18158  {
18159  Util.Free(nativeLabel);
18160  }
18161 
18162  if (formatByteCount > Util.StackAllocationSizeLimit)
18163  {
18164  Util.Free(nativeFormat);
18165  }
18166 
18167  return ret != 0;
18168  }
18169  }
18170 
18179  public static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax)
18180  {
18181  byte* nativeLabel;
18182  int labelByteCount = 0;
18183  if (label != null)
18184  {
18185  labelByteCount = Encoding.UTF8.GetByteCount(label);
18186  if (labelByteCount > Util.StackAllocationSizeLimit)
18187  {
18188  nativeLabel = Util.Allocate(labelByteCount + 1);
18189  }
18190  else
18191  {
18192  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18193  nativeLabel = nativeLabelStackBytes;
18194  }
18195 
18196  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18197  nativeLabel[nativeLabelOffset] = 0;
18198  }
18199  else
18200  {
18201  nativeLabel = null;
18202  }
18203 
18204  byte* nativeFormat;
18205  int formatByteCount = 0;
18206  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
18207  if (formatByteCount > Util.StackAllocationSizeLimit)
18208  {
18209  nativeFormat = Util.Allocate(formatByteCount + 1);
18210  }
18211  else
18212  {
18213  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18214  nativeFormat = nativeFormatStackBytes;
18215  }
18216 
18217  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
18218  nativeFormat[nativeFormatOffset] = 0;
18219  ImGuiSliderFlags flags = 0;
18220  fixed (Vector4F* nativeV = &v)
18221  {
18222  byte ret = ImGuiNative.igSliderFloat4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18223  if (labelByteCount > Util.StackAllocationSizeLimit)
18224  {
18225  Util.Free(nativeLabel);
18226  }
18227 
18228  if (formatByteCount > Util.StackAllocationSizeLimit)
18229  {
18230  Util.Free(nativeFormat);
18231  }
18232 
18233  return ret != 0;
18234  }
18235  }
18236 
18246  public static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax, string format)
18247  {
18248  byte* nativeLabel;
18249  int labelByteCount = 0;
18250  if (label != null)
18251  {
18252  labelByteCount = Encoding.UTF8.GetByteCount(label);
18253  if (labelByteCount > Util.StackAllocationSizeLimit)
18254  {
18255  nativeLabel = Util.Allocate(labelByteCount + 1);
18256  }
18257  else
18258  {
18259  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18260  nativeLabel = nativeLabelStackBytes;
18261  }
18262 
18263  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18264  nativeLabel[nativeLabelOffset] = 0;
18265  }
18266  else
18267  {
18268  nativeLabel = null;
18269  }
18270 
18271  byte* nativeFormat;
18272  int formatByteCount = 0;
18273  if (format != null)
18274  {
18275  formatByteCount = Encoding.UTF8.GetByteCount(format);
18276  if (formatByteCount > Util.StackAllocationSizeLimit)
18277  {
18278  nativeFormat = Util.Allocate(formatByteCount + 1);
18279  }
18280  else
18281  {
18282  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18283  nativeFormat = nativeFormatStackBytes;
18284  }
18285 
18286  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18287  nativeFormat[nativeFormatOffset] = 0;
18288  }
18289  else
18290  {
18291  nativeFormat = null;
18292  }
18293 
18294  ImGuiSliderFlags flags = 0;
18295  fixed (Vector4F* nativeV = &v)
18296  {
18297  byte ret = ImGuiNative.igSliderFloat4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18298  if (labelByteCount > Util.StackAllocationSizeLimit)
18299  {
18300  Util.Free(nativeLabel);
18301  }
18302 
18303  if (formatByteCount > Util.StackAllocationSizeLimit)
18304  {
18305  Util.Free(nativeFormat);
18306  }
18307 
18308  return ret != 0;
18309  }
18310  }
18311 
18322  public static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
18323  {
18324  byte* nativeLabel;
18325  int labelByteCount = 0;
18326  if (label != null)
18327  {
18328  labelByteCount = Encoding.UTF8.GetByteCount(label);
18329  if (labelByteCount > Util.StackAllocationSizeLimit)
18330  {
18331  nativeLabel = Util.Allocate(labelByteCount + 1);
18332  }
18333  else
18334  {
18335  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18336  nativeLabel = nativeLabelStackBytes;
18337  }
18338 
18339  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18340  nativeLabel[nativeLabelOffset] = 0;
18341  }
18342  else
18343  {
18344  nativeLabel = null;
18345  }
18346 
18347  byte* nativeFormat;
18348  int formatByteCount = 0;
18349  if (format != null)
18350  {
18351  formatByteCount = Encoding.UTF8.GetByteCount(format);
18352  if (formatByteCount > Util.StackAllocationSizeLimit)
18353  {
18354  nativeFormat = Util.Allocate(formatByteCount + 1);
18355  }
18356  else
18357  {
18358  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18359  nativeFormat = nativeFormatStackBytes;
18360  }
18361 
18362  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18363  nativeFormat[nativeFormatOffset] = 0;
18364  }
18365  else
18366  {
18367  nativeFormat = null;
18368  }
18369 
18370  fixed (Vector4F* nativeV = &v)
18371  {
18372  byte ret = ImGuiNative.igSliderFloat4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18373  if (labelByteCount > Util.StackAllocationSizeLimit)
18374  {
18375  Util.Free(nativeLabel);
18376  }
18377 
18378  if (formatByteCount > Util.StackAllocationSizeLimit)
18379  {
18380  Util.Free(nativeFormat);
18381  }
18382 
18383  return ret != 0;
18384  }
18385  }
18386 
18395  public static bool SliderInt(string label, ref int v, int vMin, int vMax)
18396  {
18397  byte* nativeLabel;
18398  int labelByteCount = 0;
18399  if (label != null)
18400  {
18401  labelByteCount = Encoding.UTF8.GetByteCount(label);
18402  if (labelByteCount > Util.StackAllocationSizeLimit)
18403  {
18404  nativeLabel = Util.Allocate(labelByteCount + 1);
18405  }
18406  else
18407  {
18408  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18409  nativeLabel = nativeLabelStackBytes;
18410  }
18411 
18412  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18413  nativeLabel[nativeLabelOffset] = 0;
18414  }
18415  else
18416  {
18417  nativeLabel = null;
18418  }
18419 
18420  byte* nativeFormat;
18421  int formatByteCount = 0;
18422  formatByteCount = Encoding.UTF8.GetByteCount("%d");
18423  if (formatByteCount > Util.StackAllocationSizeLimit)
18424  {
18425  nativeFormat = Util.Allocate(formatByteCount + 1);
18426  }
18427  else
18428  {
18429  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18430  nativeFormat = nativeFormatStackBytes;
18431  }
18432 
18433  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
18434  nativeFormat[nativeFormatOffset] = 0;
18435  ImGuiSliderFlags flags = 0;
18436  fixed (int* nativeV = &v)
18437  {
18438  byte ret = ImGuiNative.igSliderInt(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18439  if (labelByteCount > Util.StackAllocationSizeLimit)
18440  {
18441  Util.Free(nativeLabel);
18442  }
18443 
18444  if (formatByteCount > Util.StackAllocationSizeLimit)
18445  {
18446  Util.Free(nativeFormat);
18447  }
18448 
18449  return ret != 0;
18450  }
18451  }
18452 
18462  public static bool SliderInt(string label, ref int v, int vMin, int vMax, string format)
18463  {
18464  byte* nativeLabel;
18465  int labelByteCount = 0;
18466  if (label != null)
18467  {
18468  labelByteCount = Encoding.UTF8.GetByteCount(label);
18469  if (labelByteCount > Util.StackAllocationSizeLimit)
18470  {
18471  nativeLabel = Util.Allocate(labelByteCount + 1);
18472  }
18473  else
18474  {
18475  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18476  nativeLabel = nativeLabelStackBytes;
18477  }
18478 
18479  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18480  nativeLabel[nativeLabelOffset] = 0;
18481  }
18482  else
18483  {
18484  nativeLabel = null;
18485  }
18486 
18487  byte* nativeFormat;
18488  int formatByteCount = 0;
18489  if (format != null)
18490  {
18491  formatByteCount = Encoding.UTF8.GetByteCount(format);
18492  if (formatByteCount > Util.StackAllocationSizeLimit)
18493  {
18494  nativeFormat = Util.Allocate(formatByteCount + 1);
18495  }
18496  else
18497  {
18498  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18499  nativeFormat = nativeFormatStackBytes;
18500  }
18501 
18502  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18503  nativeFormat[nativeFormatOffset] = 0;
18504  }
18505  else
18506  {
18507  nativeFormat = null;
18508  }
18509 
18510  ImGuiSliderFlags flags = 0;
18511  fixed (int* nativeV = &v)
18512  {
18513  byte ret = ImGuiNative.igSliderInt(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18514  if (labelByteCount > Util.StackAllocationSizeLimit)
18515  {
18516  Util.Free(nativeLabel);
18517  }
18518 
18519  if (formatByteCount > Util.StackAllocationSizeLimit)
18520  {
18521  Util.Free(nativeFormat);
18522  }
18523 
18524  return ret != 0;
18525  }
18526  }
18527 
18538  public static bool SliderInt(string label, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
18539  {
18540  byte* nativeLabel;
18541  int labelByteCount = 0;
18542  if (label != null)
18543  {
18544  labelByteCount = Encoding.UTF8.GetByteCount(label);
18545  if (labelByteCount > Util.StackAllocationSizeLimit)
18546  {
18547  nativeLabel = Util.Allocate(labelByteCount + 1);
18548  }
18549  else
18550  {
18551  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18552  nativeLabel = nativeLabelStackBytes;
18553  }
18554 
18555  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18556  nativeLabel[nativeLabelOffset] = 0;
18557  }
18558  else
18559  {
18560  nativeLabel = null;
18561  }
18562 
18563  byte* nativeFormat;
18564  int formatByteCount = 0;
18565  if (format != null)
18566  {
18567  formatByteCount = Encoding.UTF8.GetByteCount(format);
18568  if (formatByteCount > Util.StackAllocationSizeLimit)
18569  {
18570  nativeFormat = Util.Allocate(formatByteCount + 1);
18571  }
18572  else
18573  {
18574  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18575  nativeFormat = nativeFormatStackBytes;
18576  }
18577 
18578  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18579  nativeFormat[nativeFormatOffset] = 0;
18580  }
18581  else
18582  {
18583  nativeFormat = null;
18584  }
18585 
18586  fixed (int* nativeV = &v)
18587  {
18588  byte ret = ImGuiNative.igSliderInt(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18589  if (labelByteCount > Util.StackAllocationSizeLimit)
18590  {
18591  Util.Free(nativeLabel);
18592  }
18593 
18594  if (formatByteCount > Util.StackAllocationSizeLimit)
18595  {
18596  Util.Free(nativeFormat);
18597  }
18598 
18599  return ret != 0;
18600  }
18601  }
18602 
18611  public static bool SliderInt2(string label, ref int v, int vMin, int vMax)
18612  {
18613  byte* nativeLabel;
18614  int labelByteCount = 0;
18615  if (label != null)
18616  {
18617  labelByteCount = Encoding.UTF8.GetByteCount(label);
18618  if (labelByteCount > Util.StackAllocationSizeLimit)
18619  {
18620  nativeLabel = Util.Allocate(labelByteCount + 1);
18621  }
18622  else
18623  {
18624  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18625  nativeLabel = nativeLabelStackBytes;
18626  }
18627 
18628  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18629  nativeLabel[nativeLabelOffset] = 0;
18630  }
18631  else
18632  {
18633  nativeLabel = null;
18634  }
18635 
18636  byte* nativeFormat;
18637  int formatByteCount = 0;
18638  formatByteCount = Encoding.UTF8.GetByteCount("%d");
18639  if (formatByteCount > Util.StackAllocationSizeLimit)
18640  {
18641  nativeFormat = Util.Allocate(formatByteCount + 1);
18642  }
18643  else
18644  {
18645  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18646  nativeFormat = nativeFormatStackBytes;
18647  }
18648 
18649  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
18650  nativeFormat[nativeFormatOffset] = 0;
18651  ImGuiSliderFlags flags = 0;
18652  fixed (int* nativeV = &v)
18653  {
18654  byte ret = ImGuiNative.igSliderInt2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18655  if (labelByteCount > Util.StackAllocationSizeLimit)
18656  {
18657  Util.Free(nativeLabel);
18658  }
18659 
18660  if (formatByteCount > Util.StackAllocationSizeLimit)
18661  {
18662  Util.Free(nativeFormat);
18663  }
18664 
18665  return ret != 0;
18666  }
18667  }
18668 
18678  public static bool SliderInt2(string label, ref int v, int vMin, int vMax, string format)
18679  {
18680  byte* nativeLabel;
18681  int labelByteCount = 0;
18682  if (label != null)
18683  {
18684  labelByteCount = Encoding.UTF8.GetByteCount(label);
18685  if (labelByteCount > Util.StackAllocationSizeLimit)
18686  {
18687  nativeLabel = Util.Allocate(labelByteCount + 1);
18688  }
18689  else
18690  {
18691  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18692  nativeLabel = nativeLabelStackBytes;
18693  }
18694 
18695  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18696  nativeLabel[nativeLabelOffset] = 0;
18697  }
18698  else
18699  {
18700  nativeLabel = null;
18701  }
18702 
18703  byte* nativeFormat;
18704  int formatByteCount = 0;
18705  if (format != null)
18706  {
18707  formatByteCount = Encoding.UTF8.GetByteCount(format);
18708  if (formatByteCount > Util.StackAllocationSizeLimit)
18709  {
18710  nativeFormat = Util.Allocate(formatByteCount + 1);
18711  }
18712  else
18713  {
18714  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18715  nativeFormat = nativeFormatStackBytes;
18716  }
18717 
18718  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18719  nativeFormat[nativeFormatOffset] = 0;
18720  }
18721  else
18722  {
18723  nativeFormat = null;
18724  }
18725 
18726  ImGuiSliderFlags flags = 0;
18727  fixed (int* nativeV = &v)
18728  {
18729  byte ret = ImGuiNative.igSliderInt2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18730  if (labelByteCount > Util.StackAllocationSizeLimit)
18731  {
18732  Util.Free(nativeLabel);
18733  }
18734 
18735  if (formatByteCount > Util.StackAllocationSizeLimit)
18736  {
18737  Util.Free(nativeFormat);
18738  }
18739 
18740  return ret != 0;
18741  }
18742  }
18743 
18754  public static bool SliderInt2(string label, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
18755  {
18756  byte* nativeLabel;
18757  int labelByteCount = 0;
18758  if (label != null)
18759  {
18760  labelByteCount = Encoding.UTF8.GetByteCount(label);
18761  if (labelByteCount > Util.StackAllocationSizeLimit)
18762  {
18763  nativeLabel = Util.Allocate(labelByteCount + 1);
18764  }
18765  else
18766  {
18767  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18768  nativeLabel = nativeLabelStackBytes;
18769  }
18770 
18771  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18772  nativeLabel[nativeLabelOffset] = 0;
18773  }
18774  else
18775  {
18776  nativeLabel = null;
18777  }
18778 
18779  byte* nativeFormat;
18780  int formatByteCount = 0;
18781  if (format != null)
18782  {
18783  formatByteCount = Encoding.UTF8.GetByteCount(format);
18784  if (formatByteCount > Util.StackAllocationSizeLimit)
18785  {
18786  nativeFormat = Util.Allocate(formatByteCount + 1);
18787  }
18788  else
18789  {
18790  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18791  nativeFormat = nativeFormatStackBytes;
18792  }
18793 
18794  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18795  nativeFormat[nativeFormatOffset] = 0;
18796  }
18797  else
18798  {
18799  nativeFormat = null;
18800  }
18801 
18802  fixed (int* nativeV = &v)
18803  {
18804  byte ret = ImGuiNative.igSliderInt2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18805  if (labelByteCount > Util.StackAllocationSizeLimit)
18806  {
18807  Util.Free(nativeLabel);
18808  }
18809 
18810  if (formatByteCount > Util.StackAllocationSizeLimit)
18811  {
18812  Util.Free(nativeFormat);
18813  }
18814 
18815  return ret != 0;
18816  }
18817  }
18818 
18827  public static bool SliderInt3(string label, ref int v, int vMin, int vMax)
18828  {
18829  byte* nativeLabel;
18830  int labelByteCount = 0;
18831  if (label != null)
18832  {
18833  labelByteCount = Encoding.UTF8.GetByteCount(label);
18834  if (labelByteCount > Util.StackAllocationSizeLimit)
18835  {
18836  nativeLabel = Util.Allocate(labelByteCount + 1);
18837  }
18838  else
18839  {
18840  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18841  nativeLabel = nativeLabelStackBytes;
18842  }
18843 
18844  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18845  nativeLabel[nativeLabelOffset] = 0;
18846  }
18847  else
18848  {
18849  nativeLabel = null;
18850  }
18851 
18852  byte* nativeFormat;
18853  int formatByteCount = 0;
18854  formatByteCount = Encoding.UTF8.GetByteCount("%d");
18855  if (formatByteCount > Util.StackAllocationSizeLimit)
18856  {
18857  nativeFormat = Util.Allocate(formatByteCount + 1);
18858  }
18859  else
18860  {
18861  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18862  nativeFormat = nativeFormatStackBytes;
18863  }
18864 
18865  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
18866  nativeFormat[nativeFormatOffset] = 0;
18867  ImGuiSliderFlags flags = 0;
18868  fixed (int* nativeV = &v)
18869  {
18870  byte ret = ImGuiNative.igSliderInt3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18871  if (labelByteCount > Util.StackAllocationSizeLimit)
18872  {
18873  Util.Free(nativeLabel);
18874  }
18875 
18876  if (formatByteCount > Util.StackAllocationSizeLimit)
18877  {
18878  Util.Free(nativeFormat);
18879  }
18880 
18881  return ret != 0;
18882  }
18883  }
18884 
18894  public static bool SliderInt3(string label, ref int v, int vMin, int vMax, string format)
18895  {
18896  byte* nativeLabel;
18897  int labelByteCount = 0;
18898  if (label != null)
18899  {
18900  labelByteCount = Encoding.UTF8.GetByteCount(label);
18901  if (labelByteCount > Util.StackAllocationSizeLimit)
18902  {
18903  nativeLabel = Util.Allocate(labelByteCount + 1);
18904  }
18905  else
18906  {
18907  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18908  nativeLabel = nativeLabelStackBytes;
18909  }
18910 
18911  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18912  nativeLabel[nativeLabelOffset] = 0;
18913  }
18914  else
18915  {
18916  nativeLabel = null;
18917  }
18918 
18919  byte* nativeFormat;
18920  int formatByteCount = 0;
18921  if (format != null)
18922  {
18923  formatByteCount = Encoding.UTF8.GetByteCount(format);
18924  if (formatByteCount > Util.StackAllocationSizeLimit)
18925  {
18926  nativeFormat = Util.Allocate(formatByteCount + 1);
18927  }
18928  else
18929  {
18930  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18931  nativeFormat = nativeFormatStackBytes;
18932  }
18933 
18934  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18935  nativeFormat[nativeFormatOffset] = 0;
18936  }
18937  else
18938  {
18939  nativeFormat = null;
18940  }
18941 
18942  ImGuiSliderFlags flags = 0;
18943  fixed (int* nativeV = &v)
18944  {
18945  byte ret = ImGuiNative.igSliderInt3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
18946  if (labelByteCount > Util.StackAllocationSizeLimit)
18947  {
18948  Util.Free(nativeLabel);
18949  }
18950 
18951  if (formatByteCount > Util.StackAllocationSizeLimit)
18952  {
18953  Util.Free(nativeFormat);
18954  }
18955 
18956  return ret != 0;
18957  }
18958  }
18959 
18970  public static bool SliderInt3(string label, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
18971  {
18972  byte* nativeLabel;
18973  int labelByteCount = 0;
18974  if (label != null)
18975  {
18976  labelByteCount = Encoding.UTF8.GetByteCount(label);
18977  if (labelByteCount > Util.StackAllocationSizeLimit)
18978  {
18979  nativeLabel = Util.Allocate(labelByteCount + 1);
18980  }
18981  else
18982  {
18983  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18984  nativeLabel = nativeLabelStackBytes;
18985  }
18986 
18987  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18988  nativeLabel[nativeLabelOffset] = 0;
18989  }
18990  else
18991  {
18992  nativeLabel = null;
18993  }
18994 
18995  byte* nativeFormat;
18996  int formatByteCount = 0;
18997  if (format != null)
18998  {
18999  formatByteCount = Encoding.UTF8.GetByteCount(format);
19000  if (formatByteCount > Util.StackAllocationSizeLimit)
19001  {
19002  nativeFormat = Util.Allocate(formatByteCount + 1);
19003  }
19004  else
19005  {
19006  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19007  nativeFormat = nativeFormatStackBytes;
19008  }
19009 
19010  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19011  nativeFormat[nativeFormatOffset] = 0;
19012  }
19013  else
19014  {
19015  nativeFormat = null;
19016  }
19017 
19018  fixed (int* nativeV = &v)
19019  {
19020  byte ret = ImGuiNative.igSliderInt3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
19021  if (labelByteCount > Util.StackAllocationSizeLimit)
19022  {
19023  Util.Free(nativeLabel);
19024  }
19025 
19026  if (formatByteCount > Util.StackAllocationSizeLimit)
19027  {
19028  Util.Free(nativeFormat);
19029  }
19030 
19031  return ret != 0;
19032  }
19033  }
19034 
19043  public static bool SliderInt4(string label, ref int v, int vMin, int vMax)
19044  {
19045  byte* nativeLabel;
19046  int labelByteCount = 0;
19047  if (label != null)
19048  {
19049  labelByteCount = Encoding.UTF8.GetByteCount(label);
19050  if (labelByteCount > Util.StackAllocationSizeLimit)
19051  {
19052  nativeLabel = Util.Allocate(labelByteCount + 1);
19053  }
19054  else
19055  {
19056  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19057  nativeLabel = nativeLabelStackBytes;
19058  }
19059 
19060  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19061  nativeLabel[nativeLabelOffset] = 0;
19062  }
19063  else
19064  {
19065  nativeLabel = null;
19066  }
19067 
19068  byte* nativeFormat;
19069  int formatByteCount = 0;
19070  formatByteCount = Encoding.UTF8.GetByteCount("%d");
19071  if (formatByteCount > Util.StackAllocationSizeLimit)
19072  {
19073  nativeFormat = Util.Allocate(formatByteCount + 1);
19074  }
19075  else
19076  {
19077  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19078  nativeFormat = nativeFormatStackBytes;
19079  }
19080 
19081  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
19082  nativeFormat[nativeFormatOffset] = 0;
19083  ImGuiSliderFlags flags = 0;
19084  fixed (int* nativeV = &v)
19085  {
19086  byte ret = ImGuiNative.igSliderInt4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
19087  if (labelByteCount > Util.StackAllocationSizeLimit)
19088  {
19089  Util.Free(nativeLabel);
19090  }
19091 
19092  if (formatByteCount > Util.StackAllocationSizeLimit)
19093  {
19094  Util.Free(nativeFormat);
19095  }
19096 
19097  return ret != 0;
19098  }
19099  }
19100 
19110  public static bool SliderInt4(string label, ref int v, int vMin, int vMax, string format)
19111  {
19112  byte* nativeLabel;
19113  int labelByteCount = 0;
19114  if (label != null)
19115  {
19116  labelByteCount = Encoding.UTF8.GetByteCount(label);
19117  if (labelByteCount > Util.StackAllocationSizeLimit)
19118  {
19119  nativeLabel = Util.Allocate(labelByteCount + 1);
19120  }
19121  else
19122  {
19123  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19124  nativeLabel = nativeLabelStackBytes;
19125  }
19126 
19127  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19128  nativeLabel[nativeLabelOffset] = 0;
19129  }
19130  else
19131  {
19132  nativeLabel = null;
19133  }
19134 
19135  byte* nativeFormat;
19136  int formatByteCount = 0;
19137  if (format != null)
19138  {
19139  formatByteCount = Encoding.UTF8.GetByteCount(format);
19140  if (formatByteCount > Util.StackAllocationSizeLimit)
19141  {
19142  nativeFormat = Util.Allocate(formatByteCount + 1);
19143  }
19144  else
19145  {
19146  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19147  nativeFormat = nativeFormatStackBytes;
19148  }
19149 
19150  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19151  nativeFormat[nativeFormatOffset] = 0;
19152  }
19153  else
19154  {
19155  nativeFormat = null;
19156  }
19157 
19158  ImGuiSliderFlags flags = 0;
19159  fixed (int* nativeV = &v)
19160  {
19161  byte ret = ImGuiNative.igSliderInt4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
19162  if (labelByteCount > Util.StackAllocationSizeLimit)
19163  {
19164  Util.Free(nativeLabel);
19165  }
19166 
19167  if (formatByteCount > Util.StackAllocationSizeLimit)
19168  {
19169  Util.Free(nativeFormat);
19170  }
19171 
19172  return ret != 0;
19173  }
19174  }
19175 
19186  public static bool SliderInt4(string label, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
19187  {
19188  byte* nativeLabel;
19189  int labelByteCount = 0;
19190  if (label != null)
19191  {
19192  labelByteCount = Encoding.UTF8.GetByteCount(label);
19193  if (labelByteCount > Util.StackAllocationSizeLimit)
19194  {
19195  nativeLabel = Util.Allocate(labelByteCount + 1);
19196  }
19197  else
19198  {
19199  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19200  nativeLabel = nativeLabelStackBytes;
19201  }
19202 
19203  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19204  nativeLabel[nativeLabelOffset] = 0;
19205  }
19206  else
19207  {
19208  nativeLabel = null;
19209  }
19210 
19211  byte* nativeFormat;
19212  int formatByteCount = 0;
19213  if (format != null)
19214  {
19215  formatByteCount = Encoding.UTF8.GetByteCount(format);
19216  if (formatByteCount > Util.StackAllocationSizeLimit)
19217  {
19218  nativeFormat = Util.Allocate(formatByteCount + 1);
19219  }
19220  else
19221  {
19222  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19223  nativeFormat = nativeFormatStackBytes;
19224  }
19225 
19226  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19227  nativeFormat[nativeFormatOffset] = 0;
19228  }
19229  else
19230  {
19231  nativeFormat = null;
19232  }
19233 
19234  fixed (int* nativeV = &v)
19235  {
19236  byte ret = ImGuiNative.igSliderInt4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flags);
19237  if (labelByteCount > Util.StackAllocationSizeLimit)
19238  {
19239  Util.Free(nativeLabel);
19240  }
19241 
19242  if (formatByteCount > Util.StackAllocationSizeLimit)
19243  {
19244  Util.Free(nativeFormat);
19245  }
19246 
19247  return ret != 0;
19248  }
19249  }
19250 
19260  public static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax)
19261  {
19262  byte* nativeLabel;
19263  int labelByteCount = 0;
19264  if (label != null)
19265  {
19266  labelByteCount = Encoding.UTF8.GetByteCount(label);
19267  if (labelByteCount > Util.StackAllocationSizeLimit)
19268  {
19269  nativeLabel = Util.Allocate(labelByteCount + 1);
19270  }
19271  else
19272  {
19273  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19274  nativeLabel = nativeLabelStackBytes;
19275  }
19276 
19277  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19278  nativeLabel[nativeLabelOffset] = 0;
19279  }
19280  else
19281  {
19282  nativeLabel = null;
19283  }
19284 
19285  void* nativePData = pData.ToPointer();
19286  void* nativePMin = pMin.ToPointer();
19287  void* nativePMax = pMax.ToPointer();
19288  byte* nativeFormat = null;
19289  ImGuiSliderFlags flags = 0;
19290  byte ret = ImGuiNative.igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
19291  if (labelByteCount > Util.StackAllocationSizeLimit)
19292  {
19293  Util.Free(nativeLabel);
19294  }
19295 
19296  return ret != 0;
19297  }
19298 
19309  public static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format)
19310  {
19311  byte* nativeLabel;
19312  int labelByteCount = 0;
19313  if (label != null)
19314  {
19315  labelByteCount = Encoding.UTF8.GetByteCount(label);
19316  if (labelByteCount > Util.StackAllocationSizeLimit)
19317  {
19318  nativeLabel = Util.Allocate(labelByteCount + 1);
19319  }
19320  else
19321  {
19322  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19323  nativeLabel = nativeLabelStackBytes;
19324  }
19325 
19326  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19327  nativeLabel[nativeLabelOffset] = 0;
19328  }
19329  else
19330  {
19331  nativeLabel = null;
19332  }
19333 
19334  void* nativePData = pData.ToPointer();
19335  void* nativePMin = pMin.ToPointer();
19336  void* nativePMax = pMax.ToPointer();
19337  byte* nativeFormat;
19338  int formatByteCount = 0;
19339  if (format != null)
19340  {
19341  formatByteCount = Encoding.UTF8.GetByteCount(format);
19342  if (formatByteCount > Util.StackAllocationSizeLimit)
19343  {
19344  nativeFormat = Util.Allocate(formatByteCount + 1);
19345  }
19346  else
19347  {
19348  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19349  nativeFormat = nativeFormatStackBytes;
19350  }
19351 
19352  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19353  nativeFormat[nativeFormatOffset] = 0;
19354  }
19355  else
19356  {
19357  nativeFormat = null;
19358  }
19359 
19360  ImGuiSliderFlags flags = 0;
19361  byte ret = ImGuiNative.igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
19362  if (labelByteCount > Util.StackAllocationSizeLimit)
19363  {
19364  Util.Free(nativeLabel);
19365  }
19366 
19367  if (formatByteCount > Util.StackAllocationSizeLimit)
19368  {
19369  Util.Free(nativeFormat);
19370  }
19371 
19372  return ret != 0;
19373  }
19374 
19386  public static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
19387  {
19388  byte* nativeLabel;
19389  int labelByteCount = 0;
19390  if (label != null)
19391  {
19392  labelByteCount = Encoding.UTF8.GetByteCount(label);
19393  if (labelByteCount > Util.StackAllocationSizeLimit)
19394  {
19395  nativeLabel = Util.Allocate(labelByteCount + 1);
19396  }
19397  else
19398  {
19399  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19400  nativeLabel = nativeLabelStackBytes;
19401  }
19402 
19403  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19404  nativeLabel[nativeLabelOffset] = 0;
19405  }
19406  else
19407  {
19408  nativeLabel = null;
19409  }
19410 
19411  void* nativePData = pData.ToPointer();
19412  void* nativePMin = pMin.ToPointer();
19413  void* nativePMax = pMax.ToPointer();
19414  byte* nativeFormat;
19415  int formatByteCount = 0;
19416  if (format != null)
19417  {
19418  formatByteCount = Encoding.UTF8.GetByteCount(format);
19419  if (formatByteCount > Util.StackAllocationSizeLimit)
19420  {
19421  nativeFormat = Util.Allocate(formatByteCount + 1);
19422  }
19423  else
19424  {
19425  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19426  nativeFormat = nativeFormatStackBytes;
19427  }
19428 
19429  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19430  nativeFormat[nativeFormatOffset] = 0;
19431  }
19432  else
19433  {
19434  nativeFormat = null;
19435  }
19436 
19437  byte ret = ImGuiNative.igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
19438  if (labelByteCount > Util.StackAllocationSizeLimit)
19439  {
19440  Util.Free(nativeLabel);
19441  }
19442 
19443  if (formatByteCount > Util.StackAllocationSizeLimit)
19444  {
19445  Util.Free(nativeFormat);
19446  }
19447 
19448  return ret != 0;
19449  }
19450 
19461  public static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax)
19462  {
19463  byte* nativeLabel;
19464  int labelByteCount = 0;
19465  if (label != null)
19466  {
19467  labelByteCount = Encoding.UTF8.GetByteCount(label);
19468  if (labelByteCount > Util.StackAllocationSizeLimit)
19469  {
19470  nativeLabel = Util.Allocate(labelByteCount + 1);
19471  }
19472  else
19473  {
19474  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19475  nativeLabel = nativeLabelStackBytes;
19476  }
19477 
19478  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19479  nativeLabel[nativeLabelOffset] = 0;
19480  }
19481  else
19482  {
19483  nativeLabel = null;
19484  }
19485 
19486  void* nativePData = pData.ToPointer();
19487  void* nativePMin = pMin.ToPointer();
19488  void* nativePMax = pMax.ToPointer();
19489  byte* nativeFormat = null;
19490  ImGuiSliderFlags flags = 0;
19491  byte ret = ImGuiNative.igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flags);
19492  if (labelByteCount > Util.StackAllocationSizeLimit)
19493  {
19494  Util.Free(nativeLabel);
19495  }
19496 
19497  return ret != 0;
19498  }
19499 
19511  public static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax, string format)
19512  {
19513  byte* nativeLabel;
19514  int labelByteCount = 0;
19515  if (label != null)
19516  {
19517  labelByteCount = Encoding.UTF8.GetByteCount(label);
19518  if (labelByteCount > Util.StackAllocationSizeLimit)
19519  {
19520  nativeLabel = Util.Allocate(labelByteCount + 1);
19521  }
19522  else
19523  {
19524  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19525  nativeLabel = nativeLabelStackBytes;
19526  }
19527 
19528  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19529  nativeLabel[nativeLabelOffset] = 0;
19530  }
19531  else
19532  {
19533  nativeLabel = null;
19534  }
19535 
19536  void* nativePData = pData.ToPointer();
19537  void* nativePMin = pMin.ToPointer();
19538  void* nativePMax = pMax.ToPointer();
19539  byte* nativeFormat;
19540  int formatByteCount = 0;
19541  if (format != null)
19542  {
19543  formatByteCount = Encoding.UTF8.GetByteCount(format);
19544  if (formatByteCount > Util.StackAllocationSizeLimit)
19545  {
19546  nativeFormat = Util.Allocate(formatByteCount + 1);
19547  }
19548  else
19549  {
19550  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19551  nativeFormat = nativeFormatStackBytes;
19552  }
19553 
19554  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19555  nativeFormat[nativeFormatOffset] = 0;
19556  }
19557  else
19558  {
19559  nativeFormat = null;
19560  }
19561 
19562  ImGuiSliderFlags flags = 0;
19563  byte ret = ImGuiNative.igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flags);
19564  if (labelByteCount > Util.StackAllocationSizeLimit)
19565  {
19566  Util.Free(nativeLabel);
19567  }
19568 
19569  if (formatByteCount > Util.StackAllocationSizeLimit)
19570  {
19571  Util.Free(nativeFormat);
19572  }
19573 
19574  return ret != 0;
19575  }
19576 
19589  public static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
19590  {
19591  byte* nativeLabel;
19592  int labelByteCount = 0;
19593  if (label != null)
19594  {
19595  labelByteCount = Encoding.UTF8.GetByteCount(label);
19596  if (labelByteCount > Util.StackAllocationSizeLimit)
19597  {
19598  nativeLabel = Util.Allocate(labelByteCount + 1);
19599  }
19600  else
19601  {
19602  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19603  nativeLabel = nativeLabelStackBytes;
19604  }
19605 
19606  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19607  nativeLabel[nativeLabelOffset] = 0;
19608  }
19609  else
19610  {
19611  nativeLabel = null;
19612  }
19613 
19614  void* nativePData = pData.ToPointer();
19615  void* nativePMin = pMin.ToPointer();
19616  void* nativePMax = pMax.ToPointer();
19617  byte* nativeFormat;
19618  int formatByteCount = 0;
19619  if (format != null)
19620  {
19621  formatByteCount = Encoding.UTF8.GetByteCount(format);
19622  if (formatByteCount > Util.StackAllocationSizeLimit)
19623  {
19624  nativeFormat = Util.Allocate(formatByteCount + 1);
19625  }
19626  else
19627  {
19628  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19629  nativeFormat = nativeFormatStackBytes;
19630  }
19631 
19632  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19633  nativeFormat[nativeFormatOffset] = 0;
19634  }
19635  else
19636  {
19637  nativeFormat = null;
19638  }
19639 
19640  byte ret = ImGuiNative.igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flags);
19641  if (labelByteCount > Util.StackAllocationSizeLimit)
19642  {
19643  Util.Free(nativeLabel);
19644  }
19645 
19646  if (formatByteCount > Util.StackAllocationSizeLimit)
19647  {
19648  Util.Free(nativeFormat);
19649  }
19650 
19651  return ret != 0;
19652  }
19653 
19659  public static bool SmallButton(string label)
19660  {
19661  byte* nativeLabel;
19662  int labelByteCount = 0;
19663  if (label != null)
19664  {
19665  labelByteCount = Encoding.UTF8.GetByteCount(label);
19666  if (labelByteCount > Util.StackAllocationSizeLimit)
19667  {
19668  nativeLabel = Util.Allocate(labelByteCount + 1);
19669  }
19670  else
19671  {
19672  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19673  nativeLabel = nativeLabelStackBytes;
19674  }
19675 
19676  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19677  nativeLabel[nativeLabelOffset] = 0;
19678  }
19679  else
19680  {
19681  nativeLabel = null;
19682  }
19683 
19684  byte ret = ImGuiNative.igSmallButton(nativeLabel);
19685  if (labelByteCount > Util.StackAllocationSizeLimit)
19686  {
19687  Util.Free(nativeLabel);
19688  }
19689 
19690  return ret != 0;
19691  }
19692 
19696  public static void Spacing()
19697  {
19698  ImGuiNative.igSpacing();
19699  }
19700 
19704  public static void StyleColorsClassic()
19705  {
19706  ImGuiStyle* dst = null;
19707  ImGuiNative.igStyleColorsClassic(dst);
19708  }
19709 
19714  public static void StyleColorsClassic(ImGuiStylePtr dst)
19715  {
19716  ImGuiStyle* nativeDst = dst.NativePtr;
19717  ImGuiNative.igStyleColorsClassic(nativeDst);
19718  }
19719 
19723  public static void StyleColorsDark()
19724  {
19725  ImGuiStyle* dst = null;
19726  ImGuiNative.igStyleColorsDark(dst);
19727  }
19728 
19733  public static void StyleColorsDark(ImGuiStylePtr dst)
19734  {
19735  ImGuiStyle* nativeDst = dst.NativePtr;
19736  ImGuiNative.igStyleColorsDark(nativeDst);
19737  }
19738 
19742  public static void StyleColorsLight()
19743  {
19744  ImGuiStyle* dst = null;
19745  ImGuiNative.igStyleColorsLight(dst);
19746  }
19747 
19752  public static void StyleColorsLight(ImGuiStylePtr dst)
19753  {
19754  ImGuiStyle* nativeDst = dst.NativePtr;
19755  ImGuiNative.igStyleColorsLight(nativeDst);
19756  }
19757 
19763  public static bool TabItemButton(string label)
19764  {
19765  byte* nativeLabel;
19766  int labelByteCount = 0;
19767  if (label != null)
19768  {
19769  labelByteCount = Encoding.UTF8.GetByteCount(label);
19770  if (labelByteCount > Util.StackAllocationSizeLimit)
19771  {
19772  nativeLabel = Util.Allocate(labelByteCount + 1);
19773  }
19774  else
19775  {
19776  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19777  nativeLabel = nativeLabelStackBytes;
19778  }
19779 
19780  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19781  nativeLabel[nativeLabelOffset] = 0;
19782  }
19783  else
19784  {
19785  nativeLabel = null;
19786  }
19787 
19788  ImGuiTabItemFlags flags = 0;
19789  byte ret = ImGuiNative.igTabItemButton(nativeLabel, flags);
19790  if (labelByteCount > Util.StackAllocationSizeLimit)
19791  {
19792  Util.Free(nativeLabel);
19793  }
19794 
19795  return ret != 0;
19796  }
19797 
19804  public static bool TabItemButton(string label, ImGuiTabItemFlags flags)
19805  {
19806  byte* nativeLabel;
19807  int labelByteCount = 0;
19808  if (label != null)
19809  {
19810  labelByteCount = Encoding.UTF8.GetByteCount(label);
19811  if (labelByteCount > Util.StackAllocationSizeLimit)
19812  {
19813  nativeLabel = Util.Allocate(labelByteCount + 1);
19814  }
19815  else
19816  {
19817  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19818  nativeLabel = nativeLabelStackBytes;
19819  }
19820 
19821  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19822  nativeLabel[nativeLabelOffset] = 0;
19823  }
19824  else
19825  {
19826  nativeLabel = null;
19827  }
19828 
19829  byte ret = ImGuiNative.igTabItemButton(nativeLabel, flags);
19830  if (labelByteCount > Util.StackAllocationSizeLimit)
19831  {
19832  Util.Free(nativeLabel);
19833  }
19834 
19835  return ret != 0;
19836  }
19837 
19842  public static int TableGetColumnCount()
19843  {
19844  int ret = ImGuiNative.igTableGetColumnCount();
19845  return ret;
19846  }
19847 
19852  public static ImGuiTableColumnFlags TableGetColumnFlags()
19853  {
19854  int columnN = -1;
19855  ImGuiTableColumnFlags ret = ImGuiNative.igTableGetColumnFlags(columnN);
19856  return ret;
19857  }
19858 
19864  public static ImGuiTableColumnFlags TableGetColumnFlags(int columnN)
19865  {
19866  ImGuiTableColumnFlags ret = ImGuiNative.igTableGetColumnFlags(columnN);
19867  return ret;
19868  }
19869 
19874  public static int TableGetColumnIndex()
19875  {
19876  int ret = ImGuiNative.igTableGetColumnIndex();
19877  return ret;
19878  }
19879 
19884  public static string TableGetColumnName()
19885  {
19886  int columnN = -1;
19887  byte* ret = ImGuiNative.igTableGetColumnName_Int(columnN);
19888  return Util.StringFromPtr(ret);
19889  }
19890 
19896  public static string TableGetColumnName(int columnN)
19897  {
19898  byte* ret = ImGuiNative.igTableGetColumnName_Int(columnN);
19899  return Util.StringFromPtr(ret);
19900  }
19901 
19906  public static int TableGetRowIndex()
19907  {
19908  int ret = ImGuiNative.igTableGetRowIndex();
19909  return ret;
19910  }
19911 
19916  public static ImGuiTableSortSpecsPtr TableGetSortSpecs()
19917  {
19918  ImGuiTableSortSpecs* ret = ImGuiNative.igTableGetSortSpecs();
19919  return new ImGuiTableSortSpecsPtr(ret);
19920  }
19921 
19926  public static void TableHeader(string label)
19927  {
19928  byte* nativeLabel;
19929  int labelByteCount = 0;
19930  if (label != null)
19931  {
19932  labelByteCount = Encoding.UTF8.GetByteCount(label);
19933  if (labelByteCount > Util.StackAllocationSizeLimit)
19934  {
19935  nativeLabel = Util.Allocate(labelByteCount + 1);
19936  }
19937  else
19938  {
19939  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19940  nativeLabel = nativeLabelStackBytes;
19941  }
19942 
19943  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19944  nativeLabel[nativeLabelOffset] = 0;
19945  }
19946  else
19947  {
19948  nativeLabel = null;
19949  }
19950 
19951  ImGuiNative.igTableHeader(nativeLabel);
19952  if (labelByteCount > Util.StackAllocationSizeLimit)
19953  {
19954  Util.Free(nativeLabel);
19955  }
19956  }
19957 
19961  public static void TableHeadersRow()
19962  {
19963  ImGuiNative.igTableHeadersRow();
19964  }
19965 
19970  public static bool TableNextColumn()
19971  {
19972  byte ret = ImGuiNative.igTableNextColumn();
19973  return ret != 0;
19974  }
19975 
19979  public static void TableNextRow()
19980  {
19981  ImGuiTableRowFlags rowFlags = 0;
19982  float minRowHeight = 0.0f;
19983  ImGuiNative.igTableNextRow(rowFlags, minRowHeight);
19984  }
19985 
19990  public static void TableNextRow(ImGuiTableRowFlags rowFlags)
19991  {
19992  float minRowHeight = 0.0f;
19993  ImGuiNative.igTableNextRow(rowFlags, minRowHeight);
19994  }
19995 
20001  public static void TableNextRow(ImGuiTableRowFlags rowFlags, float minRowHeight)
20002  {
20003  ImGuiNative.igTableNextRow(rowFlags, minRowHeight);
20004  }
20005 
20011  public static void TableSetBgColor(ImGuiTableBgTarget target, uint color)
20012  {
20013  int columnN = -1;
20014  ImGuiNative.igTableSetBgColor(target, color, columnN);
20015  }
20016 
20023  public static void TableSetBgColor(ImGuiTableBgTarget target, uint color, int columnN)
20024  {
20025  ImGuiNative.igTableSetBgColor(target, color, columnN);
20026  }
20027 
20033  public static void TableSetColumnEnabled(int columnN, bool v)
20034  {
20035  byte nativeV = v ? (byte) 1 : (byte) 0;
20036  ImGuiNative.igTableSetColumnEnabled(columnN, nativeV);
20037  }
20038 
20044  public static bool TableSetColumnIndex(int columnN)
20045  {
20046  byte ret = ImGuiNative.igTableSetColumnIndex(columnN);
20047  return ret != 0;
20048  }
20049 
20054  public static void TableSetupColumn(string label)
20055  {
20056  byte* nativeLabel;
20057  int labelByteCount = 0;
20058  if (label != null)
20059  {
20060  labelByteCount = Encoding.UTF8.GetByteCount(label);
20061  if (labelByteCount > Util.StackAllocationSizeLimit)
20062  {
20063  nativeLabel = Util.Allocate(labelByteCount + 1);
20064  }
20065  else
20066  {
20067  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20068  nativeLabel = nativeLabelStackBytes;
20069  }
20070 
20071  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20072  nativeLabel[nativeLabelOffset] = 0;
20073  }
20074  else
20075  {
20076  nativeLabel = null;
20077  }
20078 
20079  ImGuiTableColumnFlags flags = 0;
20080  float initWidthOrWeight = 0.0f;
20081  uint userId = 0;
20082  ImGuiNative.igTableSetupColumn(nativeLabel, flags, initWidthOrWeight, userId);
20083  if (labelByteCount > Util.StackAllocationSizeLimit)
20084  {
20085  Util.Free(nativeLabel);
20086  }
20087  }
20088 
20094  public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags)
20095  {
20096  byte* nativeLabel;
20097  int labelByteCount = 0;
20098  if (label != null)
20099  {
20100  labelByteCount = Encoding.UTF8.GetByteCount(label);
20101  if (labelByteCount > Util.StackAllocationSizeLimit)
20102  {
20103  nativeLabel = Util.Allocate(labelByteCount + 1);
20104  }
20105  else
20106  {
20107  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20108  nativeLabel = nativeLabelStackBytes;
20109  }
20110 
20111  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20112  nativeLabel[nativeLabelOffset] = 0;
20113  }
20114  else
20115  {
20116  nativeLabel = null;
20117  }
20118 
20119  float initWidthOrWeight = 0.0f;
20120  uint userId = 0;
20121  ImGuiNative.igTableSetupColumn(nativeLabel, flags, initWidthOrWeight, userId);
20122  if (labelByteCount > Util.StackAllocationSizeLimit)
20123  {
20124  Util.Free(nativeLabel);
20125  }
20126  }
20127 
20134  public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float initWidthOrWeight)
20135  {
20136  byte* nativeLabel;
20137  int labelByteCount = 0;
20138  if (label != null)
20139  {
20140  labelByteCount = Encoding.UTF8.GetByteCount(label);
20141  if (labelByteCount > Util.StackAllocationSizeLimit)
20142  {
20143  nativeLabel = Util.Allocate(labelByteCount + 1);
20144  }
20145  else
20146  {
20147  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20148  nativeLabel = nativeLabelStackBytes;
20149  }
20150 
20151  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20152  nativeLabel[nativeLabelOffset] = 0;
20153  }
20154  else
20155  {
20156  nativeLabel = null;
20157  }
20158 
20159  uint userId = 0;
20160  ImGuiNative.igTableSetupColumn(nativeLabel, flags, initWidthOrWeight, userId);
20161  if (labelByteCount > Util.StackAllocationSizeLimit)
20162  {
20163  Util.Free(nativeLabel);
20164  }
20165  }
20166 
20174  public static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float initWidthOrWeight, uint userId)
20175  {
20176  byte* nativeLabel;
20177  int labelByteCount = 0;
20178  if (label != null)
20179  {
20180  labelByteCount = Encoding.UTF8.GetByteCount(label);
20181  if (labelByteCount > Util.StackAllocationSizeLimit)
20182  {
20183  nativeLabel = Util.Allocate(labelByteCount + 1);
20184  }
20185  else
20186  {
20187  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20188  nativeLabel = nativeLabelStackBytes;
20189  }
20190 
20191  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20192  nativeLabel[nativeLabelOffset] = 0;
20193  }
20194  else
20195  {
20196  nativeLabel = null;
20197  }
20198 
20199  ImGuiNative.igTableSetupColumn(nativeLabel, flags, initWidthOrWeight, userId);
20200  if (labelByteCount > Util.StackAllocationSizeLimit)
20201  {
20202  Util.Free(nativeLabel);
20203  }
20204  }
20205 
20211  public static void TableSetupScrollFreeze(int cols, int rows)
20212  {
20213  ImGuiNative.igTableSetupScrollFreeze(cols, rows);
20214  }
20215 
20220  public static void Text(string fmt)
20221  {
20222  byte* nativeFmt;
20223  int fmtByteCount = 0;
20224  if (fmt != null)
20225  {
20226  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20227  if (fmtByteCount > Util.StackAllocationSizeLimit)
20228  {
20229  nativeFmt = Util.Allocate(fmtByteCount + 1);
20230  }
20231  else
20232  {
20233  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20234  nativeFmt = nativeFmtStackBytes;
20235  }
20236 
20237  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20238  nativeFmt[nativeFmtOffset] = 0;
20239  }
20240  else
20241  {
20242  nativeFmt = null;
20243  }
20244 
20245  ImGuiNative.igText(nativeFmt);
20246  if (fmtByteCount > Util.StackAllocationSizeLimit)
20247  {
20248  Util.Free(nativeFmt);
20249  }
20250  }
20251 
20257  public static void TextColored(Vector4F col, string fmt)
20258  {
20259  byte* nativeFmt;
20260  int fmtByteCount = 0;
20261  if (fmt != null)
20262  {
20263  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20264  if (fmtByteCount > Util.StackAllocationSizeLimit)
20265  {
20266  nativeFmt = Util.Allocate(fmtByteCount + 1);
20267  }
20268  else
20269  {
20270  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20271  nativeFmt = nativeFmtStackBytes;
20272  }
20273 
20274  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20275  nativeFmt[nativeFmtOffset] = 0;
20276  }
20277  else
20278  {
20279  nativeFmt = null;
20280  }
20281 
20282  ImGuiNative.igTextColored(col, nativeFmt);
20283  if (fmtByteCount > Util.StackAllocationSizeLimit)
20284  {
20285  Util.Free(nativeFmt);
20286  }
20287  }
20288 
20293  public static void TextDisabled(string fmt)
20294  {
20295  byte* nativeFmt;
20296  int fmtByteCount = 0;
20297  if (fmt != null)
20298  {
20299  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20300  if (fmtByteCount > Util.StackAllocationSizeLimit)
20301  {
20302  nativeFmt = Util.Allocate(fmtByteCount + 1);
20303  }
20304  else
20305  {
20306  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20307  nativeFmt = nativeFmtStackBytes;
20308  }
20309 
20310  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20311  nativeFmt[nativeFmtOffset] = 0;
20312  }
20313  else
20314  {
20315  nativeFmt = null;
20316  }
20317 
20318  ImGuiNative.igTextDisabled(nativeFmt);
20319  if (fmtByteCount > Util.StackAllocationSizeLimit)
20320  {
20321  Util.Free(nativeFmt);
20322  }
20323  }
20324 
20329  public static void TextUnformatted(string text)
20330  {
20331  byte* nativeText;
20332  int textByteCount = 0;
20333  if (text != null)
20334  {
20335  textByteCount = Encoding.UTF8.GetByteCount(text);
20336  if (textByteCount > Util.StackAllocationSizeLimit)
20337  {
20338  nativeText = Util.Allocate(textByteCount + 1);
20339  }
20340  else
20341  {
20342  byte* nativeTextStackBytes = stackalloc byte[textByteCount + 1];
20343  nativeText = nativeTextStackBytes;
20344  }
20345 
20346  int nativeTextOffset = Util.GetUtf8(text, nativeText, textByteCount);
20347  nativeText[nativeTextOffset] = 0;
20348  }
20349  else
20350  {
20351  nativeText = null;
20352  }
20353 
20354  byte* nativeTextEnd = null;
20355  ImGuiNative.igTextUnformatted(nativeText, nativeTextEnd);
20356  if (textByteCount > Util.StackAllocationSizeLimit)
20357  {
20358  Util.Free(nativeText);
20359  }
20360  }
20361 
20366  public static void TextWrapped(string fmt)
20367  {
20368  byte* nativeFmt;
20369  int fmtByteCount = 0;
20370  if (fmt != null)
20371  {
20372  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20373  if (fmtByteCount > Util.StackAllocationSizeLimit)
20374  {
20375  nativeFmt = Util.Allocate(fmtByteCount + 1);
20376  }
20377  else
20378  {
20379  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20380  nativeFmt = nativeFmtStackBytes;
20381  }
20382 
20383  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20384  nativeFmt[nativeFmtOffset] = 0;
20385  }
20386  else
20387  {
20388  nativeFmt = null;
20389  }
20390 
20391  ImGuiNative.igTextWrapped(nativeFmt);
20392  if (fmtByteCount > Util.StackAllocationSizeLimit)
20393  {
20394  Util.Free(nativeFmt);
20395  }
20396  }
20397 
20403  public static bool TreeNode(string label)
20404  {
20405  byte* nativeLabel;
20406  int labelByteCount = 0;
20407  if (label != null)
20408  {
20409  labelByteCount = Encoding.UTF8.GetByteCount(label);
20410  if (labelByteCount > Util.StackAllocationSizeLimit)
20411  {
20412  nativeLabel = Util.Allocate(labelByteCount + 1);
20413  }
20414  else
20415  {
20416  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20417  nativeLabel = nativeLabelStackBytes;
20418  }
20419 
20420  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20421  nativeLabel[nativeLabelOffset] = 0;
20422  }
20423  else
20424  {
20425  nativeLabel = null;
20426  }
20427 
20428  byte ret = ImGuiNative.igTreeNode_Str(nativeLabel);
20429  if (labelByteCount > Util.StackAllocationSizeLimit)
20430  {
20431  Util.Free(nativeLabel);
20432  }
20433 
20434  return ret != 0;
20435  }
20436 
20443  public static bool TreeNode(string strId, string fmt)
20444  {
20445  byte* nativeStrId;
20446  int strIdByteCount = 0;
20447  if (strId != null)
20448  {
20449  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20450  if (strIdByteCount > Util.StackAllocationSizeLimit)
20451  {
20452  nativeStrId = Util.Allocate(strIdByteCount + 1);
20453  }
20454  else
20455  {
20456  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
20457  nativeStrId = nativeStrIdStackBytes;
20458  }
20459 
20460  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
20461  nativeStrId[nativeStrIdOffset] = 0;
20462  }
20463  else
20464  {
20465  nativeStrId = null;
20466  }
20467 
20468  byte* nativeFmt;
20469  int fmtByteCount = 0;
20470  if (fmt != null)
20471  {
20472  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20473  if (fmtByteCount > Util.StackAllocationSizeLimit)
20474  {
20475  nativeFmt = Util.Allocate(fmtByteCount + 1);
20476  }
20477  else
20478  {
20479  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20480  nativeFmt = nativeFmtStackBytes;
20481  }
20482 
20483  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20484  nativeFmt[nativeFmtOffset] = 0;
20485  }
20486  else
20487  {
20488  nativeFmt = null;
20489  }
20490 
20491  byte ret = ImGuiNative.igTreeNode_StrStr(nativeStrId, nativeFmt);
20492  if (strIdByteCount > Util.StackAllocationSizeLimit)
20493  {
20494  Util.Free(nativeStrId);
20495  }
20496 
20497  if (fmtByteCount > Util.StackAllocationSizeLimit)
20498  {
20499  Util.Free(nativeFmt);
20500  }
20501 
20502  return ret != 0;
20503  }
20504 
20511  public static bool TreeNode(IntPtr ptrId, string fmt)
20512  {
20513  void* nativePtrId = ptrId.ToPointer();
20514  byte* nativeFmt;
20515  int fmtByteCount = 0;
20516  if (fmt != null)
20517  {
20518  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20519  if (fmtByteCount > Util.StackAllocationSizeLimit)
20520  {
20521  nativeFmt = Util.Allocate(fmtByteCount + 1);
20522  }
20523  else
20524  {
20525  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20526  nativeFmt = nativeFmtStackBytes;
20527  }
20528 
20529  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20530  nativeFmt[nativeFmtOffset] = 0;
20531  }
20532  else
20533  {
20534  nativeFmt = null;
20535  }
20536 
20537  byte ret = ImGuiNative.igTreeNode_Ptr(nativePtrId, nativeFmt);
20538  if (fmtByteCount > Util.StackAllocationSizeLimit)
20539  {
20540  Util.Free(nativeFmt);
20541  }
20542 
20543  return ret != 0;
20544  }
20545 
20551  public static bool TreeNodeEx(string label)
20552  {
20553  byte* nativeLabel;
20554  int labelByteCount = 0;
20555  if (label != null)
20556  {
20557  labelByteCount = Encoding.UTF8.GetByteCount(label);
20558  if (labelByteCount > Util.StackAllocationSizeLimit)
20559  {
20560  nativeLabel = Util.Allocate(labelByteCount + 1);
20561  }
20562  else
20563  {
20564  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20565  nativeLabel = nativeLabelStackBytes;
20566  }
20567 
20568  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20569  nativeLabel[nativeLabelOffset] = 0;
20570  }
20571  else
20572  {
20573  nativeLabel = null;
20574  }
20575 
20576  ImGuiTreeNodeFlags flags = 0;
20577  byte ret = ImGuiNative.igTreeNodeEx_Str(nativeLabel, flags);
20578  if (labelByteCount > Util.StackAllocationSizeLimit)
20579  {
20580  Util.Free(nativeLabel);
20581  }
20582 
20583  return ret != 0;
20584  }
20585 
20592  public static bool TreeNodeEx(string label, ImGuiTreeNodeFlags flags)
20593  {
20594  byte* nativeLabel;
20595  int labelByteCount = 0;
20596  if (label != null)
20597  {
20598  labelByteCount = Encoding.UTF8.GetByteCount(label);
20599  if (labelByteCount > Util.StackAllocationSizeLimit)
20600  {
20601  nativeLabel = Util.Allocate(labelByteCount + 1);
20602  }
20603  else
20604  {
20605  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20606  nativeLabel = nativeLabelStackBytes;
20607  }
20608 
20609  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20610  nativeLabel[nativeLabelOffset] = 0;
20611  }
20612  else
20613  {
20614  nativeLabel = null;
20615  }
20616 
20617  byte ret = ImGuiNative.igTreeNodeEx_Str(nativeLabel, flags);
20618  if (labelByteCount > Util.StackAllocationSizeLimit)
20619  {
20620  Util.Free(nativeLabel);
20621  }
20622 
20623  return ret != 0;
20624  }
20625 
20633  public static bool TreeNodeEx(string strId, ImGuiTreeNodeFlags flags, string fmt)
20634  {
20635  byte* nativeStrId;
20636  int strIdByteCount = 0;
20637  if (strId != null)
20638  {
20639  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20640  if (strIdByteCount > Util.StackAllocationSizeLimit)
20641  {
20642  nativeStrId = Util.Allocate(strIdByteCount + 1);
20643  }
20644  else
20645  {
20646  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
20647  nativeStrId = nativeStrIdStackBytes;
20648  }
20649 
20650  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
20651  nativeStrId[nativeStrIdOffset] = 0;
20652  }
20653  else
20654  {
20655  nativeStrId = null;
20656  }
20657 
20658  byte* nativeFmt;
20659  int fmtByteCount = 0;
20660  if (fmt != null)
20661  {
20662  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20663  if (fmtByteCount > Util.StackAllocationSizeLimit)
20664  {
20665  nativeFmt = Util.Allocate(fmtByteCount + 1);
20666  }
20667  else
20668  {
20669  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20670  nativeFmt = nativeFmtStackBytes;
20671  }
20672 
20673  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20674  nativeFmt[nativeFmtOffset] = 0;
20675  }
20676  else
20677  {
20678  nativeFmt = null;
20679  }
20680 
20681  byte ret = ImGuiNative.igTreeNodeEx_StrStr(nativeStrId, flags, nativeFmt);
20682  if (strIdByteCount > Util.StackAllocationSizeLimit)
20683  {
20684  Util.Free(nativeStrId);
20685  }
20686 
20687  if (fmtByteCount > Util.StackAllocationSizeLimit)
20688  {
20689  Util.Free(nativeFmt);
20690  }
20691 
20692  return ret != 0;
20693  }
20694 
20702  public static bool TreeNodeEx(IntPtr ptrId, ImGuiTreeNodeFlags flags, string fmt)
20703  {
20704  void* nativePtrId = ptrId.ToPointer();
20705  byte* nativeFmt;
20706  int fmtByteCount = 0;
20707  if (fmt != null)
20708  {
20709  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20710  if (fmtByteCount > Util.StackAllocationSizeLimit)
20711  {
20712  nativeFmt = Util.Allocate(fmtByteCount + 1);
20713  }
20714  else
20715  {
20716  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20717  nativeFmt = nativeFmtStackBytes;
20718  }
20719 
20720  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20721  nativeFmt[nativeFmtOffset] = 0;
20722  }
20723  else
20724  {
20725  nativeFmt = null;
20726  }
20727 
20728  byte ret = ImGuiNative.igTreeNodeEx_Ptr(nativePtrId, flags, nativeFmt);
20729  if (fmtByteCount > Util.StackAllocationSizeLimit)
20730  {
20731  Util.Free(nativeFmt);
20732  }
20733 
20734  return ret != 0;
20735  }
20736 
20740  public static void TreePop()
20741  {
20742  ImGuiNative.igTreePop();
20743  }
20744 
20749  public static void TreePush(string strId)
20750  {
20751  byte* nativeStrId;
20752  int strIdByteCount = 0;
20753  if (strId != null)
20754  {
20755  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20756  if (strIdByteCount > Util.StackAllocationSizeLimit)
20757  {
20758  nativeStrId = Util.Allocate(strIdByteCount + 1);
20759  }
20760  else
20761  {
20762  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
20763  nativeStrId = nativeStrIdStackBytes;
20764  }
20765 
20766  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
20767  nativeStrId[nativeStrIdOffset] = 0;
20768  }
20769  else
20770  {
20771  nativeStrId = null;
20772  }
20773 
20774  ImGuiNative.igTreePush_Str(nativeStrId);
20775  if (strIdByteCount > Util.StackAllocationSizeLimit)
20776  {
20777  Util.Free(nativeStrId);
20778  }
20779  }
20780 
20785  public static void TreePush(IntPtr ptrId)
20786  {
20787  void* nativePtrId = ptrId.ToPointer();
20788  ImGuiNative.igTreePush_Ptr(nativePtrId);
20789  }
20790 
20794  public static void Unindent()
20795  {
20796  float indentW = 0.0f;
20797  ImGuiNative.igUnindent(indentW);
20798  }
20799 
20804  public static void Unindent(float indentW)
20805  {
20806  ImGuiNative.igUnindent(indentW);
20807  }
20808 
20812  public static void UpdatePlatformWindows()
20813  {
20814  ImGuiNative.igUpdatePlatformWindows();
20815  }
20816 
20822  public static void Value(string prefix, bool b)
20823  {
20824  byte* nativePrefix;
20825  int prefixByteCount = 0;
20826  if (prefix != null)
20827  {
20828  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20829  if (prefixByteCount > Util.StackAllocationSizeLimit)
20830  {
20831  nativePrefix = Util.Allocate(prefixByteCount + 1);
20832  }
20833  else
20834  {
20835  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20836  nativePrefix = nativePrefixStackBytes;
20837  }
20838 
20839  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20840  nativePrefix[nativePrefixOffset] = 0;
20841  }
20842  else
20843  {
20844  nativePrefix = null;
20845  }
20846 
20847  byte nativeB = b ? (byte) 1 : (byte) 0;
20848  ImGuiNative.igValue_Bool(nativePrefix, nativeB);
20849  if (prefixByteCount > Util.StackAllocationSizeLimit)
20850  {
20851  Util.Free(nativePrefix);
20852  }
20853  }
20854 
20860  public static void Value(string prefix, int v)
20861  {
20862  byte* nativePrefix;
20863  int prefixByteCount = 0;
20864  if (prefix != null)
20865  {
20866  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20867  if (prefixByteCount > Util.StackAllocationSizeLimit)
20868  {
20869  nativePrefix = Util.Allocate(prefixByteCount + 1);
20870  }
20871  else
20872  {
20873  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20874  nativePrefix = nativePrefixStackBytes;
20875  }
20876 
20877  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20878  nativePrefix[nativePrefixOffset] = 0;
20879  }
20880  else
20881  {
20882  nativePrefix = null;
20883  }
20884 
20885  ImGuiNative.igValue_Int(nativePrefix, v);
20886  if (prefixByteCount > Util.StackAllocationSizeLimit)
20887  {
20888  Util.Free(nativePrefix);
20889  }
20890  }
20891 
20897  public static void Value(string prefix, uint v)
20898  {
20899  byte* nativePrefix;
20900  int prefixByteCount = 0;
20901  if (prefix != null)
20902  {
20903  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20904  if (prefixByteCount > Util.StackAllocationSizeLimit)
20905  {
20906  nativePrefix = Util.Allocate(prefixByteCount + 1);
20907  }
20908  else
20909  {
20910  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20911  nativePrefix = nativePrefixStackBytes;
20912  }
20913 
20914  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20915  nativePrefix[nativePrefixOffset] = 0;
20916  }
20917  else
20918  {
20919  nativePrefix = null;
20920  }
20921 
20922  ImGuiNative.igValue_Uint(nativePrefix, v);
20923  if (prefixByteCount > Util.StackAllocationSizeLimit)
20924  {
20925  Util.Free(nativePrefix);
20926  }
20927  }
20928 
20934  public static void Value(string prefix, float v)
20935  {
20936  byte* nativePrefix;
20937  int prefixByteCount = 0;
20938  if (prefix != null)
20939  {
20940  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20941  if (prefixByteCount > Util.StackAllocationSizeLimit)
20942  {
20943  nativePrefix = Util.Allocate(prefixByteCount + 1);
20944  }
20945  else
20946  {
20947  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20948  nativePrefix = nativePrefixStackBytes;
20949  }
20950 
20951  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20952  nativePrefix[nativePrefixOffset] = 0;
20953  }
20954  else
20955  {
20956  nativePrefix = null;
20957  }
20958 
20959  byte* nativeFloatFormat = null;
20960  ImGuiNative.igValue_Float(nativePrefix, v, nativeFloatFormat);
20961  if (prefixByteCount > Util.StackAllocationSizeLimit)
20962  {
20963  Util.Free(nativePrefix);
20964  }
20965  }
20966 
20973  public static void Value(string prefix, float v, string floatFormat)
20974  {
20975  byte* nativePrefix;
20976  int prefixByteCount = 0;
20977  if (prefix != null)
20978  {
20979  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20980  if (prefixByteCount > Util.StackAllocationSizeLimit)
20981  {
20982  nativePrefix = Util.Allocate(prefixByteCount + 1);
20983  }
20984  else
20985  {
20986  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20987  nativePrefix = nativePrefixStackBytes;
20988  }
20989 
20990  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20991  nativePrefix[nativePrefixOffset] = 0;
20992  }
20993  else
20994  {
20995  nativePrefix = null;
20996  }
20997 
20998  byte* nativeFloatFormat;
20999  int floatFormatByteCount = 0;
21000  if (floatFormat != null)
21001  {
21002  floatFormatByteCount = Encoding.UTF8.GetByteCount(floatFormat);
21003  if (floatFormatByteCount > Util.StackAllocationSizeLimit)
21004  {
21005  nativeFloatFormat = Util.Allocate(floatFormatByteCount + 1);
21006  }
21007  else
21008  {
21009  byte* nativeFloatFormatStackBytes = stackalloc byte[floatFormatByteCount + 1];
21010  nativeFloatFormat = nativeFloatFormatStackBytes;
21011  }
21012 
21013  int nativeFloatFormatOffset = Util.GetUtf8(floatFormat, nativeFloatFormat, floatFormatByteCount);
21014  nativeFloatFormat[nativeFloatFormatOffset] = 0;
21015  }
21016  else
21017  {
21018  nativeFloatFormat = null;
21019  }
21020 
21021  ImGuiNative.igValue_Float(nativePrefix, v, nativeFloatFormat);
21022  if (prefixByteCount > Util.StackAllocationSizeLimit)
21023  {
21024  Util.Free(nativePrefix);
21025  }
21026 
21027  if (floatFormatByteCount > Util.StackAllocationSizeLimit)
21028  {
21029  Util.Free(nativeFloatFormat);
21030  }
21031  }
21032 
21042  public static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax)
21043  {
21044  byte* nativeLabel;
21045  int labelByteCount = 0;
21046  if (label != null)
21047  {
21048  labelByteCount = Encoding.UTF8.GetByteCount(label);
21049  if (labelByteCount > Util.StackAllocationSizeLimit)
21050  {
21051  nativeLabel = Util.Allocate(labelByteCount + 1);
21052  }
21053  else
21054  {
21055  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21056  nativeLabel = nativeLabelStackBytes;
21057  }
21058 
21059  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21060  nativeLabel[nativeLabelOffset] = 0;
21061  }
21062  else
21063  {
21064  nativeLabel = null;
21065  }
21066 
21067  byte* nativeFormat;
21068  int formatByteCount = 0;
21069  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
21070  if (formatByteCount > Util.StackAllocationSizeLimit)
21071  {
21072  nativeFormat = Util.Allocate(formatByteCount + 1);
21073  }
21074  else
21075  {
21076  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21077  nativeFormat = nativeFormatStackBytes;
21078  }
21079 
21080  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
21081  nativeFormat[nativeFormatOffset] = 0;
21082  ImGuiSliderFlags flags = 0;
21083  fixed (float* nativeV = &v)
21084  {
21085  byte ret = ImGuiNative.igVSliderFloat(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flags);
21086  if (labelByteCount > Util.StackAllocationSizeLimit)
21087  {
21088  Util.Free(nativeLabel);
21089  }
21090 
21091  if (formatByteCount > Util.StackAllocationSizeLimit)
21092  {
21093  Util.Free(nativeFormat);
21094  }
21095 
21096  return ret != 0;
21097  }
21098  }
21099 
21110  public static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax, string format)
21111  {
21112  byte* nativeLabel;
21113  int labelByteCount = 0;
21114  if (label != null)
21115  {
21116  labelByteCount = Encoding.UTF8.GetByteCount(label);
21117  if (labelByteCount > Util.StackAllocationSizeLimit)
21118  {
21119  nativeLabel = Util.Allocate(labelByteCount + 1);
21120  }
21121  else
21122  {
21123  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21124  nativeLabel = nativeLabelStackBytes;
21125  }
21126 
21127  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21128  nativeLabel[nativeLabelOffset] = 0;
21129  }
21130  else
21131  {
21132  nativeLabel = null;
21133  }
21134 
21135  byte* nativeFormat;
21136  int formatByteCount = 0;
21137  if (format != null)
21138  {
21139  formatByteCount = Encoding.UTF8.GetByteCount(format);
21140  if (formatByteCount > Util.StackAllocationSizeLimit)
21141  {
21142  nativeFormat = Util.Allocate(formatByteCount + 1);
21143  }
21144  else
21145  {
21146  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21147  nativeFormat = nativeFormatStackBytes;
21148  }
21149 
21150  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21151  nativeFormat[nativeFormatOffset] = 0;
21152  }
21153  else
21154  {
21155  nativeFormat = null;
21156  }
21157 
21158  ImGuiSliderFlags flags = 0;
21159  fixed (float* nativeV = &v)
21160  {
21161  byte ret = ImGuiNative.igVSliderFloat(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flags);
21162  if (labelByteCount > Util.StackAllocationSizeLimit)
21163  {
21164  Util.Free(nativeLabel);
21165  }
21166 
21167  if (formatByteCount > Util.StackAllocationSizeLimit)
21168  {
21169  Util.Free(nativeFormat);
21170  }
21171 
21172  return ret != 0;
21173  }
21174  }
21175 
21187  public static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
21188  {
21189  byte* nativeLabel;
21190  int labelByteCount = 0;
21191  if (label != null)
21192  {
21193  labelByteCount = Encoding.UTF8.GetByteCount(label);
21194  if (labelByteCount > Util.StackAllocationSizeLimit)
21195  {
21196  nativeLabel = Util.Allocate(labelByteCount + 1);
21197  }
21198  else
21199  {
21200  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21201  nativeLabel = nativeLabelStackBytes;
21202  }
21203 
21204  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21205  nativeLabel[nativeLabelOffset] = 0;
21206  }
21207  else
21208  {
21209  nativeLabel = null;
21210  }
21211 
21212  byte* nativeFormat;
21213  int formatByteCount = 0;
21214  if (format != null)
21215  {
21216  formatByteCount = Encoding.UTF8.GetByteCount(format);
21217  if (formatByteCount > Util.StackAllocationSizeLimit)
21218  {
21219  nativeFormat = Util.Allocate(formatByteCount + 1);
21220  }
21221  else
21222  {
21223  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21224  nativeFormat = nativeFormatStackBytes;
21225  }
21226 
21227  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21228  nativeFormat[nativeFormatOffset] = 0;
21229  }
21230  else
21231  {
21232  nativeFormat = null;
21233  }
21234 
21235  fixed (float* nativeV = &v)
21236  {
21237  byte ret = ImGuiNative.igVSliderFloat(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flags);
21238  if (labelByteCount > Util.StackAllocationSizeLimit)
21239  {
21240  Util.Free(nativeLabel);
21241  }
21242 
21243  if (formatByteCount > Util.StackAllocationSizeLimit)
21244  {
21245  Util.Free(nativeFormat);
21246  }
21247 
21248  return ret != 0;
21249  }
21250  }
21251 
21261  public static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax)
21262  {
21263  byte* nativeLabel;
21264  int labelByteCount = 0;
21265  if (label != null)
21266  {
21267  labelByteCount = Encoding.UTF8.GetByteCount(label);
21268  if (labelByteCount > Util.StackAllocationSizeLimit)
21269  {
21270  nativeLabel = Util.Allocate(labelByteCount + 1);
21271  }
21272  else
21273  {
21274  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21275  nativeLabel = nativeLabelStackBytes;
21276  }
21277 
21278  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21279  nativeLabel[nativeLabelOffset] = 0;
21280  }
21281  else
21282  {
21283  nativeLabel = null;
21284  }
21285 
21286  byte* nativeFormat;
21287  int formatByteCount = 0;
21288  formatByteCount = Encoding.UTF8.GetByteCount("%d");
21289  if (formatByteCount > Util.StackAllocationSizeLimit)
21290  {
21291  nativeFormat = Util.Allocate(formatByteCount + 1);
21292  }
21293  else
21294  {
21295  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21296  nativeFormat = nativeFormatStackBytes;
21297  }
21298 
21299  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
21300  nativeFormat[nativeFormatOffset] = 0;
21301  ImGuiSliderFlags flags = 0;
21302  fixed (int* nativeV = &v)
21303  {
21304  byte ret = ImGuiNative.igVSliderInt(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flags);
21305  if (labelByteCount > Util.StackAllocationSizeLimit)
21306  {
21307  Util.Free(nativeLabel);
21308  }
21309 
21310  if (formatByteCount > Util.StackAllocationSizeLimit)
21311  {
21312  Util.Free(nativeFormat);
21313  }
21314 
21315  return ret != 0;
21316  }
21317  }
21318 
21329  public static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax, string format)
21330  {
21331  byte* nativeLabel;
21332  int labelByteCount = 0;
21333  if (label != null)
21334  {
21335  labelByteCount = Encoding.UTF8.GetByteCount(label);
21336  if (labelByteCount > Util.StackAllocationSizeLimit)
21337  {
21338  nativeLabel = Util.Allocate(labelByteCount + 1);
21339  }
21340  else
21341  {
21342  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21343  nativeLabel = nativeLabelStackBytes;
21344  }
21345 
21346  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21347  nativeLabel[nativeLabelOffset] = 0;
21348  }
21349  else
21350  {
21351  nativeLabel = null;
21352  }
21353 
21354  byte* nativeFormat;
21355  int formatByteCount = 0;
21356  if (format != null)
21357  {
21358  formatByteCount = Encoding.UTF8.GetByteCount(format);
21359  if (formatByteCount > Util.StackAllocationSizeLimit)
21360  {
21361  nativeFormat = Util.Allocate(formatByteCount + 1);
21362  }
21363  else
21364  {
21365  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21366  nativeFormat = nativeFormatStackBytes;
21367  }
21368 
21369  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21370  nativeFormat[nativeFormatOffset] = 0;
21371  }
21372  else
21373  {
21374  nativeFormat = null;
21375  }
21376 
21377  ImGuiSliderFlags flags = 0;
21378  fixed (int* nativeV = &v)
21379  {
21380  byte ret = ImGuiNative.igVSliderInt(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flags);
21381  if (labelByteCount > Util.StackAllocationSizeLimit)
21382  {
21383  Util.Free(nativeLabel);
21384  }
21385 
21386  if (formatByteCount > Util.StackAllocationSizeLimit)
21387  {
21388  Util.Free(nativeFormat);
21389  }
21390 
21391  return ret != 0;
21392  }
21393  }
21394 
21406  public static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
21407  {
21408  byte* nativeLabel;
21409  int labelByteCount = 0;
21410  if (label != null)
21411  {
21412  labelByteCount = Encoding.UTF8.GetByteCount(label);
21413  if (labelByteCount > Util.StackAllocationSizeLimit)
21414  {
21415  nativeLabel = Util.Allocate(labelByteCount + 1);
21416  }
21417  else
21418  {
21419  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21420  nativeLabel = nativeLabelStackBytes;
21421  }
21422 
21423  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21424  nativeLabel[nativeLabelOffset] = 0;
21425  }
21426  else
21427  {
21428  nativeLabel = null;
21429  }
21430 
21431  byte* nativeFormat;
21432  int formatByteCount = 0;
21433  if (format != null)
21434  {
21435  formatByteCount = Encoding.UTF8.GetByteCount(format);
21436  if (formatByteCount > Util.StackAllocationSizeLimit)
21437  {
21438  nativeFormat = Util.Allocate(formatByteCount + 1);
21439  }
21440  else
21441  {
21442  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21443  nativeFormat = nativeFormatStackBytes;
21444  }
21445 
21446  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21447  nativeFormat[nativeFormatOffset] = 0;
21448  }
21449  else
21450  {
21451  nativeFormat = null;
21452  }
21453 
21454  fixed (int* nativeV = &v)
21455  {
21456  byte ret = ImGuiNative.igVSliderInt(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flags);
21457  if (labelByteCount > Util.StackAllocationSizeLimit)
21458  {
21459  Util.Free(nativeLabel);
21460  }
21461 
21462  if (formatByteCount > Util.StackAllocationSizeLimit)
21463  {
21464  Util.Free(nativeFormat);
21465  }
21466 
21467  return ret != 0;
21468  }
21469  }
21470 
21481  public static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax)
21482  {
21483  byte* nativeLabel;
21484  int labelByteCount = 0;
21485  if (label != null)
21486  {
21487  labelByteCount = Encoding.UTF8.GetByteCount(label);
21488  if (labelByteCount > Util.StackAllocationSizeLimit)
21489  {
21490  nativeLabel = Util.Allocate(labelByteCount + 1);
21491  }
21492  else
21493  {
21494  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21495  nativeLabel = nativeLabelStackBytes;
21496  }
21497 
21498  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21499  nativeLabel[nativeLabelOffset] = 0;
21500  }
21501  else
21502  {
21503  nativeLabel = null;
21504  }
21505 
21506  void* nativePData = pData.ToPointer();
21507  void* nativePMin = pMin.ToPointer();
21508  void* nativePMax = pMax.ToPointer();
21509  byte* nativeFormat = null;
21510  ImGuiSliderFlags flags = 0;
21511  byte ret = ImGuiNative.igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
21512  if (labelByteCount > Util.StackAllocationSizeLimit)
21513  {
21514  Util.Free(nativeLabel);
21515  }
21516 
21517  return ret != 0;
21518  }
21519 
21531  public static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format)
21532  {
21533  byte* nativeLabel;
21534  int labelByteCount = 0;
21535  if (label != null)
21536  {
21537  labelByteCount = Encoding.UTF8.GetByteCount(label);
21538  if (labelByteCount > Util.StackAllocationSizeLimit)
21539  {
21540  nativeLabel = Util.Allocate(labelByteCount + 1);
21541  }
21542  else
21543  {
21544  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21545  nativeLabel = nativeLabelStackBytes;
21546  }
21547 
21548  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21549  nativeLabel[nativeLabelOffset] = 0;
21550  }
21551  else
21552  {
21553  nativeLabel = null;
21554  }
21555 
21556  void* nativePData = pData.ToPointer();
21557  void* nativePMin = pMin.ToPointer();
21558  void* nativePMax = pMax.ToPointer();
21559  byte* nativeFormat;
21560  int formatByteCount = 0;
21561  if (format != null)
21562  {
21563  formatByteCount = Encoding.UTF8.GetByteCount(format);
21564  if (formatByteCount > Util.StackAllocationSizeLimit)
21565  {
21566  nativeFormat = Util.Allocate(formatByteCount + 1);
21567  }
21568  else
21569  {
21570  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21571  nativeFormat = nativeFormatStackBytes;
21572  }
21573 
21574  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21575  nativeFormat[nativeFormatOffset] = 0;
21576  }
21577  else
21578  {
21579  nativeFormat = null;
21580  }
21581 
21582  ImGuiSliderFlags flags = 0;
21583  byte ret = ImGuiNative.igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
21584  if (labelByteCount > Util.StackAllocationSizeLimit)
21585  {
21586  Util.Free(nativeLabel);
21587  }
21588 
21589  if (formatByteCount > Util.StackAllocationSizeLimit)
21590  {
21591  Util.Free(nativeFormat);
21592  }
21593 
21594  return ret != 0;
21595  }
21596 
21609  public static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
21610  {
21611  byte* nativeLabel;
21612  int labelByteCount = 0;
21613  if (label != null)
21614  {
21615  labelByteCount = Encoding.UTF8.GetByteCount(label);
21616  if (labelByteCount > Util.StackAllocationSizeLimit)
21617  {
21618  nativeLabel = Util.Allocate(labelByteCount + 1);
21619  }
21620  else
21621  {
21622  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21623  nativeLabel = nativeLabelStackBytes;
21624  }
21625 
21626  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21627  nativeLabel[nativeLabelOffset] = 0;
21628  }
21629  else
21630  {
21631  nativeLabel = null;
21632  }
21633 
21634  void* nativePData = pData.ToPointer();
21635  void* nativePMin = pMin.ToPointer();
21636  void* nativePMax = pMax.ToPointer();
21637  byte* nativeFormat;
21638  int formatByteCount = 0;
21639  if (format != null)
21640  {
21641  formatByteCount = Encoding.UTF8.GetByteCount(format);
21642  if (formatByteCount > Util.StackAllocationSizeLimit)
21643  {
21644  nativeFormat = Util.Allocate(formatByteCount + 1);
21645  }
21646  else
21647  {
21648  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21649  nativeFormat = nativeFormatStackBytes;
21650  }
21651 
21652  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21653  nativeFormat[nativeFormatOffset] = 0;
21654  }
21655  else
21656  {
21657  nativeFormat = null;
21658  }
21659 
21660  byte ret = ImGuiNative.igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flags);
21661  if (labelByteCount > Util.StackAllocationSizeLimit)
21662  {
21663  Util.Free(nativeLabel);
21664  }
21665 
21666  if (formatByteCount > Util.StackAllocationSizeLimit)
21667  {
21668  Util.Free(nativeFormat);
21669  }
21670 
21671  return ret != 0;
21672  }
21673 
21681  public static bool InputText(
21682  string label,
21683  byte[] buf,
21684  uint bufSize)
21685  => InputText(label, buf, bufSize, 0, null, IntPtr.Zero);
21686 
21695  public static bool InputText(
21696  string label,
21697  byte[] buf,
21698  uint bufSize,
21699  ImGuiInputTextFlags flags)
21700  => InputText(label, buf, bufSize, flags, null, IntPtr.Zero);
21701 
21711  public static bool InputText(
21712  string label,
21713  byte[] buf,
21714  uint bufSize,
21715  ImGuiInputTextFlags flags,
21716  ImGuiInputTextCallback callback)
21717  => InputText(label, buf, bufSize, flags, callback, IntPtr.Zero);
21718 
21729  public static bool InputText(
21730  string label,
21731  byte[] buf,
21732  uint bufSize,
21733  ImGuiInputTextFlags flags,
21734  ImGuiInputTextCallback callback,
21735  IntPtr userData)
21736  {
21737  int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
21738  byte* utf8LabelBytes;
21739  if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
21740  {
21741  utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
21742  }
21743  else
21744  {
21745  byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
21746  utf8LabelBytes = stackPtr;
21747  }
21748 
21749  Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
21750 
21751  bool ret;
21752  fixed (byte* bufPtr = buf)
21753  {
21754  ret = ImGuiNative.igInputText(utf8LabelBytes, bufPtr, bufSize, flags, callback, userData.ToPointer()) != 0;
21755  }
21756 
21757  if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
21758  {
21759  Util.Free(utf8LabelBytes);
21760  }
21761 
21762  return ret;
21763  }
21764 
21772  public static bool InputText(
21773  string label,
21774  ref string input,
21775  uint maxLength) => InputText(label, ref input, maxLength, 0, null, IntPtr.Zero);
21776 
21785  public static bool InputText(
21786  string label,
21787  ref string input,
21788  uint maxLength,
21789  ImGuiInputTextFlags flags) => InputText(label, ref input, maxLength, flags, null, IntPtr.Zero);
21790 
21800  public static bool InputText(
21801  string label,
21802  ref string input,
21803  uint maxLength,
21804  ImGuiInputTextFlags flags,
21805  ImGuiInputTextCallback callback) => InputText(label, ref input, maxLength, flags, callback, IntPtr.Zero);
21806 
21817  public static bool InputText(
21818  string label,
21819  ref string input,
21820  uint maxLength,
21821  ImGuiInputTextFlags flags,
21822  ImGuiInputTextCallback callback,
21823  IntPtr userData)
21824  {
21825  // Convert label and input to ANSI strings
21826  IntPtr labelPtr = Marshal.StringToHGlobalAnsi(label);
21827  IntPtr inputPtr = Marshal.StringToHGlobalAnsi(input);
21828 
21829  // Convert ANSI strings to UTF-8 bytes
21830  byte* utf8LabelBytes = (byte*) labelPtr.ToPointer();
21831  byte* utf8InputBytes = (byte*) inputPtr.ToPointer();
21832 
21833  // Create buffers for modified input
21834  int inputBufSize = Math.Max((int) maxLength + 1, Encoding.UTF8.GetByteCount(input) + 1);
21835  byte* modifiedUtf8InputBytes = stackalloc byte[inputBufSize];
21836  byte* originalUtf8InputBytes = stackalloc byte[inputBufSize];
21837 
21838  // Copy input bytes to the modified input buffer
21839  Unsafe.CopyBlock(modifiedUtf8InputBytes, utf8InputBytes, (uint) inputBufSize);
21840 
21841  // Call the ImGuiNative method
21842  byte result = ImGuiNative.igInputText(
21843  utf8LabelBytes,
21844  modifiedUtf8InputBytes,
21845  (uint) inputBufSize,
21846  flags,
21847  callback,
21848  userData.ToPointer());
21849 
21850  // Check if the input was modified and update the input variable accordingly
21851  if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, modifiedUtf8InputBytes))
21852  {
21853  input = Encoding.UTF8.GetString(modifiedUtf8InputBytes, inputBufSize);
21854  }
21855 
21856  // Free the memory allocated by Marshal.StringToHGlobalAnsi
21857  Marshal.FreeHGlobal(labelPtr);
21858  Marshal.FreeHGlobal(inputPtr);
21859 
21860  return result != 0;
21861  }
21862 
21863 
21872  public static bool InputTextMultiline(
21873  string label,
21874  ref string input,
21875  uint maxLength,
21876  Vector2F size) => InputTextMultiline(label, ref input, maxLength, size, 0, null, IntPtr.Zero);
21877 
21887  public static bool InputTextMultiline(
21888  string label,
21889  ref string input,
21890  uint maxLength,
21891  Vector2F size,
21892  ImGuiInputTextFlags flags) => InputTextMultiline(label, ref input, maxLength, size, flags, null, IntPtr.Zero);
21893 
21904  public static bool InputTextMultiline(
21905  string label,
21906  ref string input,
21907  uint maxLength,
21908  Vector2F size,
21909  ImGuiInputTextFlags flags,
21910  ImGuiInputTextCallback callback) => InputTextMultiline(label, ref input, maxLength, size, flags, callback, IntPtr.Zero);
21911 
21923  public static bool InputTextMultiline(
21924  string label,
21925  ref string input,
21926  uint maxLength,
21927  Vector2F size,
21928  ImGuiInputTextFlags flags,
21929  ImGuiInputTextCallback callback,
21930  IntPtr userData)
21931  {
21932  // Convert label and input to ANSI strings
21933  IntPtr labelPtr = Marshal.StringToHGlobalAnsi(label);
21934  IntPtr inputPtr = Marshal.StringToHGlobalAnsi(input);
21935 
21936  // Convert ANSI strings to UTF-8 bytes
21937  byte* utf8LabelBytes = (byte*) labelPtr.ToPointer();
21938  byte* utf8InputBytes = (byte*) inputPtr.ToPointer();
21939 
21940  // Create buffers for modified input
21941  int inputBufSize = Math.Max((int) maxLength + 1, Encoding.UTF8.GetByteCount(input) + 1);
21942  byte* modifiedUtf8InputBytes = stackalloc byte[inputBufSize];
21943  byte* originalUtf8InputBytes = stackalloc byte[inputBufSize];
21944 
21945  // Copy input bytes to the modified input buffer
21946  Unsafe.CopyBlock(modifiedUtf8InputBytes, utf8InputBytes, (uint) inputBufSize);
21947 
21948  // Call the ImGuiNative method
21949  byte result = ImGuiNative.igInputTextMultiline(
21950  utf8LabelBytes,
21951  modifiedUtf8InputBytes,
21952  (uint) inputBufSize,
21953  size,
21954  flags,
21955  callback,
21956  userData.ToPointer());
21957 
21958  // Check if the input was modified and update the input variable accordingly
21959  if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, modifiedUtf8InputBytes))
21960  {
21961  input = Encoding.UTF8.GetString(modifiedUtf8InputBytes, inputBufSize);
21962  }
21963 
21964  // Free the memory allocated by Marshal.StringToHGlobalAnsi
21965  Marshal.FreeHGlobal(labelPtr);
21966  Marshal.FreeHGlobal(inputPtr);
21967 
21968  return result != 0;
21969  }
21970 
21971 
21978  public static bool AreByteArraysEqual(byte[] array1, byte[] array2)
21979  {
21980  if ((array1 == null) && (array2 == null))
21981  {
21982  return true;
21983  }
21984 
21985  if (array1 == null || array2 == null || array1.Length != array2.Length)
21986  {
21987  return false;
21988  }
21989 
21990  for (int i = 0; i < array1.Length; i++)
21991  {
21992  if (array1[i] != array2[i])
21993  {
21994  return false;
21995  }
21996  }
21997 
21998  return true;
21999  }
22000 
22001 
22010  public static bool InputTextWithHint(
22011  string label,
22012  string hint,
22013  ref string input,
22014  uint maxLength) => InputTextWithHint(label, hint, ref input, maxLength, 0, null, IntPtr.Zero);
22015 
22025  public static bool InputTextWithHint(
22026  string label,
22027  string hint,
22028  ref string input,
22029  uint maxLength,
22030  ImGuiInputTextFlags flags) => InputTextWithHint(label, hint, ref input, maxLength, flags, null, IntPtr.Zero);
22031 
22042  public static bool InputTextWithHint(
22043  string label,
22044  string hint,
22045  ref string input,
22046  uint maxLength,
22047  ImGuiInputTextFlags flags,
22048  ImGuiInputTextCallback callback) => InputTextWithHint(label, hint, ref input, maxLength, flags, callback, IntPtr.Zero);
22049 
22061  public static bool InputTextWithHint(
22062  string label,
22063  string hint,
22064  ref string input,
22065  uint maxLength,
22066  ImGuiInputTextFlags flags,
22067  ImGuiInputTextCallback callback,
22068  IntPtr userData)
22069  {
22070  byte* utf8LabelBytes = GetUtf8Bytes(label);
22071  byte* utf8HintBytes = GetUtf8Bytes(hint);
22072  byte* utf8InputBytes = GetUtf8Bytes(input, maxLength);
22073 
22074  byte result = ImGuiNative.igInputTextWithHint(
22075  utf8LabelBytes,
22076  utf8HintBytes,
22077  utf8InputBytes,
22078  maxLength + 1,
22079  flags,
22080  callback,
22081  userData.ToPointer());
22082 
22083  bool hasInputChanged = !AreUtf8StringsEqual(utf8InputBytes, input);
22084  if (hasInputChanged)
22085  {
22086  input = GetStringFromUtf8(utf8InputBytes);
22087  }
22088 
22089  FreeUtf8Bytes(utf8LabelBytes);
22090  FreeUtf8Bytes(utf8HintBytes);
22091  FreeUtf8Bytes(utf8InputBytes);
22092 
22093  return result != 0;
22094  }
22095 
22101  private static byte* GetUtf8Bytes(string text)
22102  {
22103  int byteCount = Encoding.UTF8.GetByteCount(text);
22104  byte* utf8Bytes = (byte*) Marshal.AllocHGlobal(byteCount + 1);
22105  Util.GetUtf8(text, utf8Bytes, byteCount);
22106  utf8Bytes[byteCount] = 0; // Null-terminate the string
22107  return utf8Bytes;
22108  }
22109 
22110 
22117  private static byte* GetUtf8Bytes(string text, uint maxLength)
22118  {
22119  int byteCount = Encoding.UTF8.GetByteCount(text);
22120  int inputBufSize = Math.Max((int) maxLength + 1, byteCount + 1);
22121  byte[] utf8BytesArray = new byte[inputBufSize];
22122 
22123  fixed (byte* utf8Bytes = utf8BytesArray)
22124  {
22125  Util.GetUtf8(text, utf8Bytes, inputBufSize);
22126  Unsafe.InitBlockUnaligned(utf8Bytes, 0, (uint) inputBufSize);
22127 
22128  byte* result = (byte*) Marshal.AllocHGlobal(inputBufSize);
22129  Buffer.MemoryCopy(utf8Bytes, result, inputBufSize, inputBufSize);
22130 
22131  return result;
22132  }
22133  }
22134 
22135 
22142  private static bool AreUtf8StringsEqual(byte* utf8Bytes, string text)
22143  {
22144  int byteCount = Encoding.UTF8.GetByteCount(text);
22145  return Util.AreStringsEqual(utf8Bytes, byteCount, utf8Bytes);
22146  }
22147 
22153  private static string GetStringFromUtf8(byte* utf8Bytes) => Util.StringFromPtr(utf8Bytes);
22154 
22159  private static void FreeUtf8Bytes(byte* utf8Bytes)
22160  {
22161  int allocatedSize = GetUtf8BytesLength(utf8Bytes);
22162  if (allocatedSize > Util.StackAllocationSizeLimit)
22163  {
22164  Util.Free(utf8Bytes);
22165  }
22166  }
22167 
22173  private static int GetUtf8BytesLength(byte* utf8Bytes)
22174  {
22175  if (utf8Bytes == null)
22176  {
22177  return 0;
22178  }
22179 
22180  int length = 0;
22181  while (*(utf8Bytes + length) != 0)
22182  {
22183  length++;
22184  }
22185 
22186  return length;
22187  }
22188 
22189 
22195  public static Vector2F CalcTextSize(string text)
22196  => CalcTextSizeImpl(text);
22197 
22204  public static Vector2F CalcTextSize(string text, int start)
22205  => CalcTextSizeImpl(text, start);
22206 
22213  public static Vector2F CalcTextSize(string text, float wrapWidth)
22214  => CalcTextSizeImpl(text, wrapWidth: wrapWidth);
22215 
22222  public static Vector2F CalcTextSize(string text, bool hideTextAfterDoubleHash)
22223  => CalcTextSizeImpl(text, hideTextAfterDoubleHash: hideTextAfterDoubleHash);
22224 
22232  public static Vector2F CalcTextSize(string text, int start, int length)
22233  => CalcTextSizeImpl(text, start, length);
22234 
22242  public static Vector2F CalcTextSize(string text, int start, bool hideTextAfterDoubleHash)
22243  => CalcTextSizeImpl(text, start, hideTextAfterDoubleHash: hideTextAfterDoubleHash);
22244 
22252  public static Vector2F CalcTextSize(string text, int start, float wrapWidth)
22253  => CalcTextSizeImpl(text, start, wrapWidth: wrapWidth);
22254 
22262  public static Vector2F CalcTextSize(string text, bool hideTextAfterDoubleHash, float wrapWidth)
22263  => CalcTextSizeImpl(text, hideTextAfterDoubleHash: hideTextAfterDoubleHash, wrapWidth: wrapWidth);
22264 
22273  public static Vector2F CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash)
22274  => CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash);
22275 
22284  public static Vector2F CalcTextSize(string text, int start, int length, float wrapWidth)
22285  => CalcTextSizeImpl(text, start, length, wrapWidth: wrapWidth);
22286 
22296  public static Vector2F CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
22297  => CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash, wrapWidth);
22298 
22308  private static Vector2F CalcTextSizeImpl(
22309  string text,
22310  int start = 0,
22311  int? length = null,
22312  bool hideTextAfterDoubleHash = false,
22313  float wrapWidth = -1.0f)
22314  {
22315  Vector2F ret;
22316  byte* nativeTextStart = null;
22317  byte* nativeTextEnd = null;
22318  int textByteCount = 0;
22319  if (text != null)
22320  {
22321  int textToCopyLen = length.HasValue ? length.Value : text.Length;
22322  textByteCount = Util.CalcSizeInUtf8(text, start, textToCopyLen);
22323  if (textByteCount > Util.StackAllocationSizeLimit)
22324  {
22325  nativeTextStart = Util.Allocate(textByteCount + 1);
22326  }
22327  else
22328  {
22329  byte* nativeTextStackBytes = stackalloc byte[textByteCount + 1];
22330  nativeTextStart = nativeTextStackBytes;
22331  }
22332 
22333  int nativeTextOffset = Util.GetUtf8(text, start, textToCopyLen, nativeTextStart, textByteCount);
22334  nativeTextStart[nativeTextOffset] = 0;
22335  nativeTextEnd = nativeTextStart + nativeTextOffset;
22336  }
22337 
22338  ImGuiNative.igCalcTextSize(&ret, nativeTextStart, nativeTextEnd, *(byte*) &hideTextAfterDoubleHash, wrapWidth);
22339  if (textByteCount > Util.StackAllocationSizeLimit)
22340  {
22341  Util.Free(nativeTextStart);
22342  }
22343 
22344  return ret;
22345  }
22346 
22354  public static bool InputText(
22355  string label,
22356  IntPtr buf,
22357  uint bufSize)
22358  => InputText(label, buf, bufSize, 0, null, IntPtr.Zero);
22359 
22368  public static bool InputText(
22369  string label,
22370  IntPtr buf,
22371  uint bufSize,
22372  ImGuiInputTextFlags flags)
22373  => InputText(label, buf, bufSize, flags, null, IntPtr.Zero);
22374 
22384  public static bool InputText(
22385  string label,
22386  IntPtr buf,
22387  uint bufSize,
22388  ImGuiInputTextFlags flags,
22389  ImGuiInputTextCallback callback)
22390  => InputText(label, buf, bufSize, flags, callback, IntPtr.Zero);
22391 
22402  public static bool InputText(
22403  string label,
22404  IntPtr buf,
22405  uint bufSize,
22406  ImGuiInputTextFlags flags,
22407  ImGuiInputTextCallback callback,
22408  IntPtr userData)
22409  {
22410  int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
22411  byte* utf8LabelBytes;
22412  if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
22413  {
22414  utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
22415  }
22416  else
22417  {
22418  byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
22419  utf8LabelBytes = stackPtr;
22420  }
22421 
22422  Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
22423 
22424  bool ret = ImGuiNative.igInputText(utf8LabelBytes, (byte*) buf.ToPointer(), bufSize, flags, callback, userData.ToPointer()) != 0;
22425 
22426  if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
22427  {
22428  Util.Free(utf8LabelBytes);
22429  }
22430 
22431  return ret;
22432  }
22433 
22440  public static bool Begin(string name, ImGuiWindowFlags flags)
22441  {
22442  int utf8NameByteCount = Encoding.UTF8.GetByteCount(name);
22443  byte* utf8NameBytes;
22444  if (utf8NameByteCount > Util.StackAllocationSizeLimit)
22445  {
22446  utf8NameBytes = Util.Allocate(utf8NameByteCount + 1);
22447  }
22448  else
22449  {
22450  byte* stackPtr = stackalloc byte[utf8NameByteCount + 1];
22451  utf8NameBytes = stackPtr;
22452  }
22453 
22454  Util.GetUtf8(name, utf8NameBytes, utf8NameByteCount);
22455 
22456  byte* pOpen = null;
22457  byte ret = ImGuiNative.igBegin(utf8NameBytes, pOpen, flags);
22458 
22459  if (utf8NameByteCount > Util.StackAllocationSizeLimit)
22460  {
22461  Util.Free(utf8NameBytes);
22462  }
22463 
22464  return ret != 0;
22465  }
22466 
22473  public static bool MenuItem(string label, bool enabled) => MenuItem(label, string.Empty, false, enabled);
22474  }
22475 }
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetBgColor
static void igTableSetBgColor(ImGuiTableBgTarget target, uint color, int columnN)
Igs the table set bg color using the specified target
Alis.Core.Graphic.ImGui.ImGui.DockSpaceOverViewport
static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags)
Docks the space over viewport using the specified viewport
Definition: ImGui.cs:3465
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed, int vMin)
Describes whether drag int 2
Definition: ImGui.cs:6317
Alis.Core.Graphic.ImGui.Structs.ImGuiPayloadPtr
The im gui payload ptr
Definition: ImGuiPayloadPtr.cs:40
Alis.Core.Graphic.ImGui.ImGui.SetWindowFontScale
static void SetWindowFontScale(float scale)
Sets the window font scale using the specified scale
Definition: ImGui.cs:16772
Alis.Core.Graphic.ImGui.ImGui.ColorEdit4
static bool ColorEdit4(string label, ref Vector4F col)
Describes whether color edit 4
Definition: ImGui.cs:2540
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igNextColumn
static void igNextColumn()
Igs the next column
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseReleased_Nil
static byte igIsMouseReleased_Nil(ImGuiMouseButton button)
Igs the is mouse released nil using the specified button
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int range 2
Definition: ImGui.cs:7734
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast)
Describes whether input scalar n
Definition: ImGui.cs:12216
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int
Definition: ImGui.cs:6033
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowClass
static void SetNextWindowClass(ImGuiWindowClassPtr windowClass)
Sets the next window using the specified window class
Definition: ImGui.cs:16275
Alis.Core.Graphic.ImGui.ImGui.BeginTable
static bool BeginTable(string strId, int column, ImGuiTableFlags flags, Vector2F outerSize)
Describes whether begin table
Definition: ImGui.cs:1723
Alis.Core.Graphic.ImGui.ImGui.GetKeyName
static string GetKeyName(ImGuiKey key)
Gets the key name using the specified key
Definition: ImGui.cs:9374
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnFlags
static ImGuiTableColumnFlags TableGetColumnFlags(int columnN)
Tables the get column flags using the specified column n
Definition: ImGui.cs:19864
Alis.Core.Aspect.Math.Vector.Vector4F
Vector4F is a struct represent a glsl vec4 value
Definition: Vector4F.cs:40
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNodeEx_StrStr
static byte igTreeNodeEx_StrStr(byte *strId, ImGuiTreeNodeFlags flags, byte *fmt)
Igs the tree node ex str str using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowClass
static void igSetNextWindowClass(ImGuiWindowClass *windowClass)
Igs the set next window using the specified window class
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputInt
static byte igInputInt(byte *label, int *v, int step, int stepFast, ImGuiInputTextFlags flags)
Igs the input int using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether drag float 2
Definition: ImGui.cs:4263
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowDrawList
static ImDrawList * igGetWindowDrawList()
Igs the get window draw list
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(uint id, Vector2F size, bool border, ImGuiWindowFlags flags)
Describes whether begin child
Definition: ImGui.cs:524
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowContentRegionMax
static void igGetWindowContentRegionMax(Vector2F *pOut)
Igs the get window content region max using the specified p out
Alis.Core.Graphic.ImGui.ImGui.GetColumnWidth
static float GetColumnWidth(int columnIndex)
Gets the column width using the specified column index
Definition: ImGui.cs:9050
Alis.Core.Graphic.ImGui.Enums.ImGuiPopupFlags
ImGuiPopupFlags
The im gui popup flags enum
Definition: ImGuiPopupFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.StyleColorsDark
static void StyleColorsDark(ImGuiStylePtr dst)
Styles the colors dark using the specified dst
Definition: ImGui.cs:19733
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginTable
static byte igBeginTable(byte *strId, int column, ImGuiTableFlags flags, Vector2F outerSize, float innerWidth)
Igs the begin table using the specified str id
Alis.Core.Graphic.ImGui.ImGui.BeginMenu
static bool BeginMenu(string label)
Describes whether begin menu
Definition: ImGui.cs:849
Alis.Core.Graphic.ImGui.ImGui.IsItemVisible
static bool IsItemVisible()
Describes whether is item visible
Definition: ImGui.cs:12649
Alis.Core.Graphic.ImGui.ImGui.SetWindowPos
static void SetWindowPos(Vector2F pos)
Sets the window pos using the specified pos
Definition: ImGui.cs:16781
Alis.Core.Graphic.ImGui.ImGui.VSliderInt
static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether v slider int
Definition: ImGui.cs:21406
Alis.Core.Graphic.ImGui.ImGui.SetNextFrameWantCaptureMouse
static void SetNextFrameWantCaptureMouse(bool wantCaptureMouse)
Sets the next frame want capture mouse using the specified want capture mouse
Definition: ImGui.cs:16225
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCombo_Str
static byte igCombo_Str(byte *label, int *currentItem, byte *itemsSeparatedByZeros, int popupMaxHeightInItems)
Igs the combo str using the specified label
Alis.Core.Graphic.ImGui.ImGui.EndTooltip
static void EndTooltip()
Ends the tooltip
Definition: ImGui.cs:8866
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed)
Describes whether drag int range 2
Definition: ImGui.cs:7515
Alis.Core.Graphic.ImGui.ImGui.GetWindowPos
static Vector2F GetWindowPos()
Gets the window pos
Definition: ImGui.cs:9693
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetItemDefaultFocus
static void igSetItemDefaultFocus()
Igs the set item default focus
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
Describes whether drag scalar
Definition: ImGui.cs:8302
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData)
Describes whether drag scalar
Definition: ImGui.cs:8029
Alis.Core.Graphic.ImGui.ImGui.EndFrame
static void EndFrame()
Ends the frame
Definition: ImGui.cs:8786
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowViewport
static ImGuiViewport * igGetWindowViewport()
Igs the get window viewport
Alis.Core.Graphic.ImGui.ImGui.InputTextMultiline
static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2F size)
Describes whether input text multiline
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsAnyItemActive
static byte igIsAnyItemActive()
Igs the is any item active
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCalcTextSize
static void igCalcTextSize(Vector2F *pOut, byte *text, byte *textEnd, byte hideTextAfterDoubleHash, float wrapWidth)
Igs the calc text size using the specified p out
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushTextWrapPos
static void igPushTextWrapPos(float wrapLocalPosX)
Igs the push text wrap pos using the specified wrap local pos x
Alis.Core.Graphic.ImGui.Utils.Util.Free
static void Free(byte *ptr)
Frees the ptr
Alis.Core.Graphic.ImGui.ImGui.ColorEdit4
static bool ColorEdit4(string label, ref Vector4F col, ImGuiColorEditFlags flags)
Describes whether color edit 4
Definition: ImGui.cs:2585
Alis.Core.Graphic.ImGui.ImGui.InputFloat4
static bool InputFloat4(string label, ref Vector4F v, string format, ImGuiInputTextFlags flags)
Describes whether input float 4
Definition: ImGui.cs:11305
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowStyleSelector
static byte igShowStyleSelector(byte *label)
Igs the show style selector using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCombo_Str_arr
static byte igCombo_Str_arr(byte *label, int *currentItem, byte **items, int itemsCount, int popupMaxHeightInItems)
Igs the combo str arr using the specified label
Alis.Core.Graphic.ImGui.Enums.ImGuiDockNodeFlags
ImGuiDockNodeFlags
The im gui dock node flags enum
Definition: ImGuiDockNodeFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.InputFloat3
static bool InputFloat3(string label, ref Vector3F v, string format, ImGuiInputTextFlags flags)
Describes whether input float 3
Definition: ImGui.cs:11095
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v)
Describes whether drag int 4
Definition: ImGui.cs:7021
Alis.Core.Graphic.ImGui.ImGui.MemAlloc
static IntPtr MemAlloc(uint size)
Mems the alloc using the specified size
Definition: ImGui.cs:13490
Alis.Core.Graphic.ImGui.ImGui.OpenPopupOnItemClick
static void OpenPopupOnItemClick()
Opens the popup on item click
Definition: ImGui.cs:14029
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax)
Plots the lines using the specified label
Definition: ImGui.cs:14833
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderInt
static byte igSliderInt(byte *label, int *v, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the slider int using the specified label
Alis.Core.Graphic.ImGui.ImGui.SetDragDropPayload
static bool SetDragDropPayload(string type, IntPtr data, uint sz, ImGuiCond cond)
Describes whether set drag drop payload
Definition: ImGui.cs:16133
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginListBox
static byte igBeginListBox(byte *label, Vector2F size)
Igs the begin list box using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowStyleEditor
static void igShowStyleEditor(ImGuiStyle * @ref)
Alis.Core.Graphic.ImGui.ImGui.PushClipRect
static void PushClipRect(Vector2F clipRectMin, Vector2F clipRectMax, bool intersectWithCurrentClipRect)
Pushes the clip rect using the specified clip rect min
Definition: ImGui.cs:15216
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetID_Ptr
static uint igGetID_Ptr(void *ptrId)
Igs the get id ptr using the specified ptr id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowDockID
static uint igGetWindowDockID()
Igs the get window dock id
Alis.Core.Graphic.ImGui.ImGui.TableNextColumn
static bool TableNextColumn()
Describes whether table next column
Definition: ImGui.cs:19970
Alis.Core.Graphic.ImGui.ImGui.GetStringFromUtf8
static string GetStringFromUtf8(byte *utf8Bytes)
Gets the string from utf 8 using the specified utf 8 bytes
Alis.Core.Graphic.ImGui.ImGui.Begin
static bool Begin(string name, ref bool pOpen)
Describes whether begin
Definition: ImGui.cs:221
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetID_Str
static uint igGetID_Str(byte *strId)
Igs the get id str using the specified str id
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast, string format)
Describes whether input scalar n
Definition: ImGui.cs:12266
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSpacing
static void igSpacing()
Igs the spacing
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextVoid
static bool BeginPopupContextVoid(string strId)
Describes whether begin popup context void
Definition: ImGui.cs:1124
Alis.Core.Graphic.ImGui.ImGui.PopId
static void PopId()
Pops the id
Definition: ImGui.cs:15075
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetStyleColorName
static byte * igGetStyleColorName(ImGuiCol idx)
Igs the get style color name using the specified idx
Alis.Core.Graphic.ImGui.ImGui.TreeNodeEx
static bool TreeNodeEx(string label)
Describes whether tree node ex
Definition: ImGui.cs:20551
Alis.Core.Graphic.ImGui.ImGui.GetMouseDragDelta
static Vector2F GetMouseDragDelta(ImGuiMouseButton button)
Gets the mouse drag delta using the specified button
Definition: ImGui.cs:9442
Alis.Core.Graphic.ImGui.ImGui.BeginPopupModal
static bool BeginPopupModal(string name, ref bool pOpen, ImGuiWindowFlags flags)
Describes whether begin popup modal
Definition: ImGui.cs:1383
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputFloat
static byte igInputFloat(byte *label, float *v, float step, float stepFast, byte *format, ImGuiInputTextFlags flags)
Igs the input float using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowHovered
static byte igIsWindowHovered(ImGuiHoveredFlags flags)
Igs the is window hovered using the specified flags
Alis.Core.Graphic.ImGui.ImGui.DockSpaceOverViewport
static uint DockSpaceOverViewport(ImGuiViewportPtr viewport)
Docks the space over viewport using the specified viewport
Definition: ImGui.cs:3450
Alis.Core.Graphic.ImGui.ImGui.IsAnyMouseDown
static bool IsAnyMouseDown()
Describes whether is any mouse down
Definition: ImGui.cs:12525
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetColumnWidth
static void igSetColumnWidth(int columnIndex, float width)
Igs the set column width using the specified column index
Alis.Core.Graphic.ImGui.ImGui.GetDrawListSharedData
static IntPtr GetDrawListSharedData()
Gets the draw list shared data
Definition: ImGui.cs:9165
Alis.Core.Graphic.ImGui.ImGui.FindViewportByPlatformHandle
static ImGuiViewportPtr FindViewportByPlatformHandle(IntPtr platformHandle)
Finds the viewport by platform handle using the specified platform handle
Definition: ImGui.cs:8887
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushClipRect
static void igPushClipRect(Vector2F clipRectMin, Vector2F clipRectMax, byte intersectWithCurrentClipRect)
Igs the push clip rect using the specified clip rect min
Alis.Core.Graphic.ImGui.ImGui.IsAnyItemFocused
static bool IsAnyItemFocused()
Describes whether is any item focused
Definition: ImGui.cs:12505
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin)
Describes whether drag scalar
Definition: ImGui.cs:8125
Alis.Core.Graphic.ImGui.ImGui.BeginDisabled
static void BeginDisabled()
Begins the disabled
Definition: ImGui.cs:698
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputFloat3
static byte igInputFloat3(byte *label, Vector3F *v, byte *format, ImGuiInputTextFlags flags)
Igs the input float 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.IsKeyDown
static bool IsKeyDown(ImGuiKey key)
Describes whether is key down
Definition: ImGui.cs:12660
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText)
Plots the histogram using the specified label
Definition: ImGui.cs:14212
Alis.Core.Graphic.ImGui.ImGui.IsWindowHovered
static bool IsWindowHovered()
Describes whether is window hovered
Definition: ImGui.cs:12995
Alis.Core.Graphic.ImGui.ImGui.BeginMenu
static bool BeginMenu(string label, bool enabled)
Describes whether begin menu
Definition: ImGui.cs:890
Alis.Core.Graphic.ImGui.Utils.Unsafe
Contains generic, low-level functionality for manipulating pointers.
Definition: Unsafe.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igRender
static void igRender()
Igs the render
Alis.Core.Graphic.ImGui.Utils.Util.StackAllocationSizeLimit
const int StackAllocationSizeLimit
The stack allocation size limit
Definition: Util.cs:44
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextFrameWantCaptureMouse
static void igSetNextFrameWantCaptureMouse(byte wantCaptureMouse)
Igs the set next frame want capture mouse using the specified want capture mouse
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSaveIniSettingsToDisk
static void igSaveIniSettingsToDisk(byte *iniFilename)
Igs the save ini settings to disk using the specified ini filename
Alis.Core.Graphic.ImGui.Structs.ImGuiStyle
The im gui style
Definition: ImGuiStyle.cs:39
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast)
Describes whether input scalar
Definition: ImGui.cs:11920
Alis.Core.Graphic.ImGui.Structs.ImGuiStoragePtr.NativePtr
ImGuiStorage * NativePtr
Gets the value of the native ptr
Definition: ImGuiStoragePtr.cs:43
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowBgAlpha
static void SetNextWindowBgAlpha(float alpha)
Sets the next window bg alpha using the specified alpha
Definition: ImGui.cs:16266
Alis.Core.Graphic.ImGui.ImGui.GetWindowHeight
static float GetWindowHeight()
Gets the window height
Definition: ImGui.cs:9683
Alis.Core.Graphic.ImGui.ImGui.CreateContext
static IntPtr CreateContext(ImFontAtlasPtr sharedFontAtlas)
Creates the context using the specified shared font atlas
Definition: ImGui.cs:3261
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize)
Plots the histogram using the specified label
Definition: ImGui.cs:14440
Alis.Core.Graphic.ImGui.ImGui.EndChild
static void EndChild()
Ends the child
Definition: ImGui.cs:8738
Alis.Core.Graphic.ImGui.ImGui.GetWindowDrawList
static ImDrawListPtr GetWindowDrawList()
Gets the window draw list
Definition: ImGui.cs:9673
Alis.Core.Graphic.ImGui.ImGui.IsAnyItemActive
static bool IsAnyItemActive()
Describes whether is any item active
Definition: ImGui.cs:12495
Alis.Core.Graphic.ImGui.ImGui.PushButtonRepeat
static void PushButtonRepeat(bool repeat)
Pushes the button repeat using the specified repeat
Definition: ImGui.cs:15204
Alis.Core.Graphic.ImGui.ImGui.InputInt3
static bool InputInt3(string label, ref int v)
Describes whether input int 3
Definition: ImGui.cs:11648
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed)
Describes whether drag float 2
Definition: ImGui.cs:3982
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int 4
Definition: ImGui.cs:7293
Alis.Core.Graphic.ImGui.Structs.ImGuiViewport
The im gui viewport
Definition: ImGuiViewport.cs:39
Alis.Core.Graphic.ImGui.ImGui.GetFontTexUvWhitePixel
static Vector2F GetFontTexUvWhitePixel()
Gets the font tex uv white pixel
Definition: ImGui.cs:9195
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetColumnName_Int
static byte * igTableGetColumnName_Int(int columnN)
Igs the table get column name int using the specified column n
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin)
Plots the histogram using the specified label
Definition: ImGui.cs:14288
Alis.Core.Graphic.ImGui.ImGui.GetContentRegionMax
static Vector2F GetContentRegionMax()
Gets the content region max
Definition: ImGui.cs:9071
Alis.Core.Graphic.ImGui.ImGui.InputFloat2
static bool InputFloat2(string label, ref Vector2F v, string format)
Describes whether input float 2
Definition: ImGui.cs:10811
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetTabItemClosed
static void igSetTabItemClosed(byte *tabOrDockedWindowLabel)
Igs the set tab item closed using the specified tab or docked window label
Alis.Core.Graphic.ImGui.ImGui.VSliderScalar
static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax)
Describes whether v slider scalar
Definition: ImGui.cs:21481
Alis.Core.Graphic.ImGui.ImGui.InputInt
static bool InputInt(string label, ref int v, int step, int stepFast)
Describes whether input int
Definition: ImGui.cs:11470
Alis.Core.Graphic.ImGui.Structs.ImFontAtlasPtr.NativePtr
ImFontAtlas * NativePtr
Gets the value of the native ptr
Definition: ImFontAtlasPtr.cs:46
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v)
Describes whether drag int
Definition: ImGui.cs:5761
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed, float vMin)
Describes whether drag float
Definition: ImGui.cs:3630
Alis.Core.Graphic.ImGui.ImGui.GetWindowViewport
static ImGuiViewportPtr GetWindowViewport()
Gets the window viewport
Definition: ImGui.cs:9715
Alis.Core.Graphic.ImGui.Utils.Util.GetUtf8
static int GetUtf8(string s, byte *utf8Bytes, int utf8ByteCount)
Gets the utf 8 using the specified s
Definition: Util.cs:128
Alis.Core.Graphic.ImGui.ImGui.BeginCombo
static bool BeginCombo(string label, string previewValue)
Describes whether begin combo
Definition: ImGui.cs:563
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetIO
static ImGuiIo * igGetIO()
Igs the get io
Alis.Core.Graphic.ImGui.Structs.ImGuiIo
The im gui io
Definition: ImGuiIO.cs:40
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogToClipboard
static void igLogToClipboard(int autoOpenDepth)
Igs the log to clipboard using the specified auto open depth
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColumnOffset
static float igGetColumnOffset(int columnIndex)
Igs the get column offset using the specified column index
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushItemWidth
static void igPushItemWidth(float itemWidth)
Igs the push item width using the specified item width
Alis.Core.Graphic.ImGui.ImGui.GetScrollMaxY
static float GetScrollMaxY()
Gets the scroll max y
Definition: ImGui.cs:9509
Alis.Core.Graphic.ImGui.ImGui.EndTabItem
static void EndTabItem()
Ends the tab item
Definition: ImGui.cs:8850
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorPos
static void igGetCursorPos(Vector2F *pOut)
Igs the get cursor pos using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorPosY
static float igGetCursorPosY()
Igs the get cursor pos y
Alis.Core.Graphic.ImGui.ImGui.IsMouseDragging
static bool IsMouseDragging(ImGuiMouseButton button, float lockThreshold)
Describes whether is mouse dragging
Definition: ImGui.cs:12767
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax)
Describes whether drag int 3
Definition: ImGui.cs:6805
Alis.Core.Graphic.ImGui.ImGui.IsWindowHovered
static bool IsWindowHovered(ImGuiHoveredFlags flags)
Describes whether is window hovered
Definition: ImGui.cs:13007
Alis.Core.Graphic.ImGui.ImGui.InputInt3
static bool InputInt3(string label, ref int v, ImGuiInputTextFlags flags)
Describes whether input int 3
Definition: ImGui.cs:11693
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopup
static byte igBeginPopup(byte *strId, ImGuiWindowFlags flags)
Igs the begin popup using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogToTTY
static void igLogToTTY(int autoOpenDepth)
Igs the log to tty using the specified auto open depth
Alis.Core.Graphic.ImGui.Enums.ImGuiDir
ImGuiDir
The im gui dir enum
Definition: ImGuiDir.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiViewportPtr.NativePtr
ImGuiViewport * NativePtr
Gets the value of the native ptr
Definition: ImGuiViewportPtr.cs:45
Alis.Core.Graphic.ImGui.ImGui.TextWrapped
static void TextWrapped(string fmt)
Texts the wrapped using the specified fmt
Definition: ImGui.cs:20366
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNodeEx_Str
static byte igTreeNodeEx_Str(byte *label, ImGuiTreeNodeFlags flags)
Igs the tree node ex str using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetWindowSize
static Vector2F GetWindowSize()
Gets the window size
Definition: ImGui.cs:9704
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloat2
static byte igDragFloat2(byte *label, Vector2F *v, float vSpeed, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the drag float 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetId
static uint GetId(string strId)
Gets the id using the specified str id
Definition: ImGui.cs:9259
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float 3
Definition: ImGui.cs:4606
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderInt3
static byte igSliderInt3(byte *label, int *v, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the slider int 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetKeyPressedAmount
static int GetKeyPressedAmount(ImGuiKey key, float repeatDelay, float rate)
Gets the key pressed amount using the specified key
Definition: ImGui.cs:9387
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igOpenPopup_ID
static void igOpenPopup_ID(uint id, ImGuiPopupFlags popupFlags)
Igs the open popup id using the specified id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetStyle
static ImGuiStyle * igGetStyle()
Igs the get style
Alis.Core.Graphic.ImGui.ImGui.SameLine
static void SameLine()
Sames the line
Definition: ImGui.cs:15511
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndPopup
static void igEndPopup()
Igs the end popup
Alis.Core.Graphic.ImGui.ImGui.InputInt
static bool InputInt(string label, ref int v, int step)
Describes whether input int
Definition: ImGui.cs:11423
Alis.Core.Graphic.ImGui.ImGui.IsKeyPressed
static bool IsKeyPressed(ImGuiKey key, bool repeat)
Describes whether is key pressed
Definition: ImGui.cs:12684
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragIntRange2
static byte igDragIntRange2(byte *label, int *vCurrentMin, int *vCurrentMax, float vSpeed, int vMin, int vMax, byte *format, byte *formatMax, ImGuiSliderFlags flags)
Igs the drag int range 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetItemRectSize
static Vector2F GetItemRectSize()
Gets the item rect size
Definition: ImGui.cs:9351
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPlotLines_FloatPtr
static void igPlotLines_FloatPtr(byte *label, float *values, int valuesCount, int valuesOffset, byte *overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
Igs the plot lines float ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetWindowContentRegionMax
static Vector2F GetWindowContentRegionMax()
Gets the window content region max
Definition: ImGui.cs:9631
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetContentRegionMax
static void igGetContentRegionMax(Vector2F *pOut)
Igs the get content region max using the specified p out
Alis.Core.Graphic.ImGui.ImGui.Columns
static void Columns(int count)
Columnses the count
Definition: ImGui.cs:2863
Alis.Core.Graphic.ImGui.ImGui.SliderFloat2
static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax)
Describes whether slider float 2
Definition: ImGui.cs:17747
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnName
static string TableGetColumnName(int columnN)
Tables the get column name using the specified column n
Definition: ImGui.cs:19896
Alis.Core.Graphic.ImGui.ImGui.ShowStyleSelector
static bool ShowStyleSelector(string label)
Describes whether show style selector
Definition: ImGui.cs:17133
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderInt2
static byte igSliderInt2(byte *label, int *v, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the slider int 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.Begin
static bool Begin(string name, ref bool pOpen, ImGuiWindowFlags flags)
Describes whether begin
Definition: ImGui.cs:266
Alis.Core.Graphic.ImGui.ImGui.GetColumnsCount
static int GetColumnsCount()
Gets the columns count
Definition: ImGui.cs:9028
Alis.Core.Graphic.ImGui.ImGui.PopFont
static void PopFont()
Pops the font
Definition: ImGui.cs:15067
Alis.Core.Graphic.ImGui.ImGui.TreePush
static void TreePush(IntPtr ptrId)
Trees the push using the specified ptr id
Definition: ImGui.cs:20785
Alis.Core.Graphic.ImGui.ImGui.SaveIniSettingsToMemory
static string SaveIniSettingsToMemory()
Saves the ini settings to memory
Definition: ImGui.cs:15578
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowContentSize
static void igSetNextWindowContentSize(Vector2F size)
Igs the set next window content size using the specified size
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset)
Plots the lines using the specified label
Definition: ImGui.cs:14633
Alis.Core.Graphic.ImGui.ImGui.TreeNode
static bool TreeNode(string label)
Describes whether tree node
Definition: ImGui.cs:20403
Alis.Core.Graphic.ImGui.ImGui.GetCursorPosY
static float GetCursorPosY()
Gets the cursor pos y
Definition: ImGui.cs:9113
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderInt4
static byte igSliderInt4(byte *label, int *v, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the slider int 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.InputTextWithHint
static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTextFlags flags)
Describes whether input text with hint
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igResetMouseDragDelta
static void igResetMouseDragDelta(ImGuiMouseButton button)
Igs the reset mouse drag delta using the specified button
Alis.Core.Graphic.ImGui.ImGui.GetIo
static ImGuiIoPtr GetIo()
Gets the io
Definition: ImGui.cs:9309
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginDragDropTarget
static byte igBeginDragDropTarget()
Igs the begin drag drop target
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed)
Describes whether drag int
Definition: ImGui.cs:5829
Alis.Core.Graphic.ImGui.ImGui.Render
static void Render()
Renders
Definition: ImGui.cs:15452
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFrameCount
static int igGetFrameCount()
Igs the get frame count
Alis.Core.Graphic.ImGui.ImGui.Begin
static bool Begin(string name)
Describes whether begin
Definition: ImGui.cs:179
Alis.Core.Graphic.ImGui.ImGui.SetTabItemClosed
static void SetTabItemClosed(string tabOrDockedWindowLabel)
Sets the tab item closed using the specified tab or docked window label
Definition: ImGui.cs:16556
Alis.Core.Graphic.ImGui.Utils.Unsafe.InitBlockUnaligned
static unsafe void InitBlockUnaligned(void *startAddress, byte value, uint byteCount)
Initializes a block of memory at the given location with a given initial value without assuming archi...
Definition: Unsafe.cs:85
Alis.Core.Graphic.ImGui.ImGui.RenderPlatformWindowsDefault
static void RenderPlatformWindowsDefault(IntPtr platformRenderArg, IntPtr rendererRenderArg)
Renders the platform windows default using the specified platform render arg
Definition: ImGui.cs:15483
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax)
Describes whether drag float
Definition: ImGui.cs:3698
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNode_Ptr
static byte igTreeNode_Ptr(void *ptrId, byte *fmt)
Igs the tree node ptr using the specified ptr id
Alis.Core.Graphic.ImGui.Structs.ImGuiPlatformIoPtr
The im gui platform io ptr
Definition: ImGuiPlatformIOPtr.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColumnIndex
static int igGetColumnIndex()
Igs the get column index
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin)
Describes whether drag float 3
Definition: ImGui.cs:4470
Alis.Core.Graphic.ImGui.ImGui.TreePush
static void TreePush(string strId)
Trees the push using the specified str id
Definition: ImGui.cs:20749
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v)
Describes whether drag float 4
Definition: ImGui.cs:4754
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowFocus_Str
static void igSetWindowFocus_Str(byte *name)
Igs the set window focus str using the specified name
Alis.Core.Graphic.ImGui.ImGui.SliderScalar
static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
Describes whether slider scalar
Definition: ImGui.cs:19386
Alis.Core.Graphic.ImGui.ImGui.SliderInt2
static bool SliderInt2(string label, ref int v, int vMin, int vMax, string format)
Describes whether slider int 2
Definition: ImGui.cs:18678
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragInt2
static byte igDragInt2(byte *label, int *v, float vSpeed, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the drag int 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.VSliderFloat
static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax, string format)
Describes whether v slider float
Definition: ImGui.cs:21110
Alis.Core.Graphic.ImGui.ImGui.SetScrollFromPosY
static void SetScrollFromPosY(float localY, float centerYRatio)
Sets the scroll from pos y using the specified local y
Definition: ImGui.cs:16483
Alis.Core.Graphic.ImGui.ImGui.VSliderScalar
static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format)
Describes whether v slider scalar
Definition: ImGui.cs:21531
Alis.Core.Graphic.ImGui.ImGui.TableNextRow
static void TableNextRow(ImGuiTableRowFlags rowFlags)
Tables the next row using the specified row flags
Definition: ImGui.cs:19990
Alis.Core.Graphic.ImGui.ImGui.ShowUserGuide
static void ShowUserGuide()
Shows the user guide
Definition: ImGui.cs:17170
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin)
Describes whether drag float 4
Definition: ImGui.cs:4890
Alis.Core.Graphic.ImGui.ImGui.IsPopupOpen
static bool IsPopupOpen(string strId, ImGuiPopupFlags flags)
Describes whether is popup open
Definition: ImGui.cs:12882
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNode_StrStr
static byte igTreeNode_StrStr(byte *strId, byte *fmt)
Igs the tree node str str using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igVSliderScalar
static byte igVSliderScalar(byte *label, Vector2F size, ImGuiDataType dataType, void *pData, void *pMin, void *pMax, byte *format, ImGuiSliderFlags flags)
Igs the v slider scalar using the specified label
Alis.Core.Aspect
Definition: AlisObject.cs:33
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowPos
static void igSetNextWindowPos(Vector2F pos, ImGuiCond cond, Vector2F pivot)
Igs the set next window pos using the specified pos
Alis.Core.Graphic.ImGui.ImGui.SetItemDefaultFocus
static void SetItemDefaultFocus()
Sets the item default focus
Definition: ImGui.cs:16179
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogFinish
static void igLogFinish()
Igs the log finish
Alis.Core.Graphic.ImGui.ImGui.CheckboxFlags
static bool CheckboxFlags(string label, ref int flags, int flagsValue)
Describes whether checkbox flags
Definition: ImGui.cs:1995
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopClipRect
static void igPopClipRect()
Igs the pop clip rect
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBulletText
static void igBulletText(byte *fmt)
Igs the bullet text using the specified fmt
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginDisabled
static void igBeginDisabled(byte disabled)
Igs the begin disabled using the specified disabled
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin)
Describes whether drag float 2
Definition: ImGui.cs:4050
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMouseClickedCount
static int igGetMouseClickedCount(ImGuiMouseButton button)
Igs the get mouse clicked count using the specified button
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTextUnformatted
static void igTextUnformatted(byte *text, byte *textEnd)
Igs the text unformatted using the specified text
Alis.Core.Graphic.ImGui.ImGui.RenderPlatformWindowsDefault
static void RenderPlatformWindowsDefault()
Renders the platform windows default
Definition: ImGui.cs:15460
Alis.Core.Graphic.ImGui.ImGui.ShowDebugLogWindow
static void ShowDebugLogWindow()
Shows the debug log window
Definition: ImGui.cs:16993
Alis.Core.Graphic.ImGui.ImGui.SliderScalarN
static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
Describes whether slider scalar n
Definition: ImGui.cs:19589
Alis.Core.Graphic.ImGui.ImGui.EndListBox
static void EndListBox()
Ends the list box
Definition: ImGui.cs:8802
Alis.Core.Graphic.ImGui.ImGui.IsMousePosValid
static bool IsMousePosValid()
Describes whether is mouse pos valid
Definition: ImGui.cs:12804
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, IntPtr buf, uint bufSize, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr userData)
Describes whether input text
Definition: ImGui.cs:22402
Alis.Core.Graphic.ImGui.ImGui.BeginTabBar
static bool BeginTabBar(string strId)
Describes whether begin tab bar
Definition: ImGui.cs:1425
Alis.Core.Graphic.ImGui.ImGui.TabItemButton
static bool TabItemButton(string label, ImGuiTabItemFlags flags)
Describes whether tab item button
Definition: ImGui.cs:19804
Alis.Core.Graphic.ImGui.ImGui.CloseCurrentPopup
static void CloseCurrentPopup()
Closes the current popup
Definition: ImGui.cs:2079
Alis.Core.Graphic.ImGui.ImGui.PopClipRect
static void PopClipRect()
Pops the clip rect
Definition: ImGui.cs:15059
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format, string formatMax, ImGuiSliderFlags flags)
Describes whether drag float range 2
Definition: ImGui.cs:5659
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size)
Describes whether image button
Definition: ImGui.cs:9808
Alis.Core.Graphic.ImGui.ImGui.UpdatePlatformWindows
static void UpdatePlatformWindows()
Updates the platform windows
Definition: ImGui.cs:20812
Alis.Core.Graphic.ImGui.ImGui.TreeNode
static bool TreeNode(IntPtr ptrId, string fmt)
Describes whether tree node
Definition: ImGui.cs:20511
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorPosX
static float igGetCursorPosX()
Igs the get cursor pos x
Alis.Core.Graphic.ImGui.ImGui.PopStyleColor
static void PopStyleColor(int count)
Pops the style color using the specified count
Definition: ImGui.cs:15101
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnIndex
static int TableGetColumnIndex()
Tables the get column index
Definition: ImGui.cs:19874
Alis.Core.Graphic.ImGui.ImGui.ColorEdit3
static bool ColorEdit3(string label, ref Vector3F col, ImGuiColorEditFlags flags)
Describes whether color edit 3
Definition: ImGui.cs:2497
Alis.Core.Graphic.ImGui.ImGui.ShowMetricsWindow
static void ShowMetricsWindow(ref bool pOpen)
Shows the metrics window using the specified p open
Definition: ImGui.cs:17081
Alis.Core.Graphic.ImGui.ImGui.SliderInt2
static bool SliderInt2(string label, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether slider int 2
Definition: ImGui.cs:18754
Alis.Core.Graphic.ImGui.ImGui.GetCursorPos
static Vector2F GetCursorPos()
Gets the cursor pos
Definition: ImGui.cs:9092
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSelectable_Bool
static byte igSelectable_Bool(byte *label, byte selected, ImGuiSelectableFlags flags, Vector2F size)
Igs the selectable bool using the specified label
Alis.Core.Graphic.ImGui.ImGui.ProgressBar
static void ProgressBar(float fraction, Vector2F sizeArg)
Progresses the bar using the specified fraction
Definition: ImGui.cs:15156
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorConvertHSVtoRGB
static void igColorConvertHSVtoRGB(float h, float s, float v, float *outR, float *outG, float *outB)
Igs the color convert hs vto rgb using the specified h
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetColorEditOptions
static void igSetColorEditOptions(ImGuiColorEditFlags flags)
Igs the set color edit options using the specified flags
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0)
Describes whether image button
Definition: ImGui.cs:9854
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorConvertU32ToFloat4
static void igColorConvertU32ToFloat4(Vector4F *pOut, uint @in)
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowBgAlpha
static void igSetNextWindowBgAlpha(float alpha)
Igs the set next window bg alpha using the specified alpha
Alis.Core.Graphic.ImGui.ImGui.MemFree
static void MemFree(IntPtr ptr)
Mems the free using the specified ptr
Definition: ImGui.cs:13500
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igRadioButton_Bool
static byte igRadioButton_Bool(byte *label, byte active)
Igs the radio button bool using the specified label
Alis.Core.Graphic.ImGui.ImGui.LogButtons
static void LogButtons()
Logs the buttons
Definition: ImGui.cs:13343
Alis.Core.Graphic.ImGui.ImGui.TableSetColumnIndex
static bool TableSetColumnIndex(int columnN)
Describes whether table set column index
Definition: ImGui.cs:20044
Alis.Core.Graphic.ImGui.ImGui.OpenPopupOnItemClick
static void OpenPopupOnItemClick(string strId)
Opens the popup on item click using the specified str id
Definition: ImGui.cs:14040
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowDockId
static void SetNextWindowDockId(uint dockId)
Sets the next window dock id using the specified dock id
Definition: ImGui.cs:16316
Alis.Core.Graphic.ImGui.ImGui.InputTextWithHint
static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
Describes whether input text with hint
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetScrollMaxX
static float igGetScrollMaxX()
Igs the get scroll max x
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIndent
static void igIndent(float indentW)
Igs the indent using the specified indent w
Alis.Core.Graphic.ImGui.ImGui.SetWindowFocus
static void SetWindowFocus(string name)
Sets the window focus using the specified name
Definition: ImGui.cs:16736
Alis.Core.Graphic.ImGui.Delegates
Definition: ImGuiInputTextCallback.cs:34
Alis.Core.Graphic.ImGui.ImGui.OpenPopup
static void OpenPopup(uint id)
Opens the popup using the specified id
Definition: ImGui.cs:14010
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
Plots the lines using the specified label
Definition: ImGui.cs:14985
Alis.Core.Graphic.ImGui.Structs.ImGuiWindowClass
The im gui window
Definition: ImGuiWindowClass.cs:38
Alis.Core.Graphic.ImGui.ImGui.Unindent
static void Unindent(float indentW)
Unindents the indent w
Definition: ImGui.cs:20804
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsRectVisible_Nil
static byte igIsRectVisible_Nil(Vector2F size)
Igs the is rect visible nil using the specified size
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowScroll
static void SetNextWindowScroll(Vector2F scroll)
Sets the next window scroll using the specified scroll
Definition: ImGui.cs:16377
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCursorPosX
static void igSetCursorPosX(float localX)
Igs the set cursor pos x using the specified local x
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, bool hideTextAfterDoubleHash, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetStateStorage
static void igSetStateStorage(ImGuiStorage *storage)
Igs the set state storage using the specified storage
Alis.Core.Graphic.ImGui.ImGui.SliderFloat3
static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether slider float 3
Definition: ImGui.cs:18106
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCursorPos
static void igSetCursorPos(Vector2F localPos)
Igs the set cursor pos using the specified local pos
Alis.Core.Graphic.ImGui.ImGui.SliderInt4
static bool SliderInt4(string label, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether slider int 4
Definition: ImGui.cs:19186
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderFloat2
static byte igSliderFloat2(byte *label, Vector2F *v, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the slider float 2 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndDisabled
static void igEndDisabled()
Igs the end disabled
Alis.Core.Graphic.ImGui.ImGui.NewFrame
static void NewFrame()
News the frame
Definition: ImGui.cs:13911
Alis.Core.Graphic.ImGui.ImGui.LoadIniSettingsFromMemory
static void LoadIniSettingsFromMemory(string iniData)
Loads the ini settings from memory using the specified ini data
Definition: ImGui.cs:13270
Alis.Core.Graphic.ImGui.ImGui.GetUtf8Bytes
static byte * GetUtf8Bytes(string text, uint maxLength)
Gets the utf 8 bytes using the specified text
Definition: ImGui.cs:22117
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowPos
static void SetNextWindowPos(Vector2F pos, ImGuiCond cond, Vector2F pivot)
Sets the next window pos using the specified pos
Definition: ImGui.cs:16368
Alis.Core.Graphic.ImGui.Enums.ImGuiHoveredFlags
ImGuiHoveredFlags
The im gui hovered flags enum
Definition: ImGuiHoveredFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.BeginDragDropSource
static bool BeginDragDropSource(ImGuiDragDropFlags flags)
Describes whether begin drag drop source
Definition: ImGui.cs:730
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, byte[] buf, uint bufSize, ImGuiInputTextFlags flags)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowSizeConstraints
static void igSetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback, void *customCallbackData)
Igs the set next window size constraints using the specified size min
Alis.Core.Graphic.ImGui.ImGui.GetCursorPosX
static float GetCursorPosX()
Gets the cursor pos x
Definition: ImGui.cs:9103
Alis.Core.Graphic.ImGui.ImGui.BeginTabItem
static bool BeginTabItem(string label, ref bool pOpen, ImGuiTabItemFlags flags)
Describes whether begin tab item
Definition: ImGui.cs:1592
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(uint id, Vector2F size, bool border)
Describes whether begin child
Definition: ImGui.cs:508
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginChild_Str
static byte igBeginChild_Str(byte *strId, Vector2F size, byte border, ImGuiWindowFlags flags)
Igs the begin child str using the specified str id
Alis.Core.Graphic.ImGui.ImGui.VSliderFloat
static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether v slider float
Definition: ImGui.cs:21187
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether drag float
Definition: ImGui.cs:3843
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igMemFree
static void igMemFree(void *ptr)
Igs the mem free using the specified ptr
Alis.Core.Graphic.ImGui.ImGui.TableSetupColumn
static void TableSetupColumn(string label, ImGuiTableColumnFlags flags)
Tables the setup column using the specified label
Definition: ImGui.cs:20094
Alis.Core.Graphic.ImGui.ImGui.GetWindowWidth
static float GetWindowWidth()
Gets the window width
Definition: ImGui.cs:9725
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igValue_Float
static void igValue_Float(byte *prefix, float v, byte *floatFormat)
Igs the value float using the specified prefix
Alis.Core.Graphic.ImGui.ImGui.IsMousePosValid
static bool IsMousePosValid(ref Vector2F mousePos)
Describes whether is mouse pos valid
Definition: ImGui.cs:12816
Alis.Core.Graphic.ImGui.ImGui.FindViewportById
static ImGuiViewportPtr FindViewportById(uint id)
Finds the viewport by id using the specified id
Definition: ImGui.cs:8876
Alis.Core.Graphic.ImGui.ImGui.Bullet
static void Bullet()
Bullets
Definition: ImGui.cs:1814
Alis.Core.Graphic.ImGui.ImGui.DebugCheckVersionAndDataLayout
static bool DebugCheckVersionAndDataLayout(string versionStr, uint szIo, uint szStyle, uint szVec2, uint szVec4, uint szDrawvert, uint szDrawidx)
Describes whether debug check version and data layout
Definition: ImGui.cs:3279
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderFloat4
static byte igSliderFloat4(byte *label, Vector4F *v, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the slider float 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.InputFloat4
static bool InputFloat4(string label, ref Vector4F v, string format)
Describes whether input float 4
Definition: ImGui.cs:11231
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderAngle
static byte igSliderAngle(byte *label, float *vRad, float vDegreesMin, float vDegreesMax, byte *format, ImGuiSliderFlags flags)
Igs the slider angle using the specified label
Alis.Core.Graphic.ImGui.ImGui.EndPopup
static void EndPopup()
Ends the popup
Definition: ImGui.cs:8834
Alis.Core.Graphic.ImGui.ImGui.SliderFloat2
static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax, string format)
Describes whether slider float 2
Definition: ImGui.cs:17814
Alis.Core.Graphic.ImGui.ImGui.SetWindowPos
static void SetWindowPos(string name, Vector2F pos, ImGuiCond cond)
Sets the window pos using the specified name
Definition: ImGui.cs:16841
Alis.Core.Graphic.ImGui.ImGui.Unindent
static void Unindent()
Unindents
Definition: ImGui.cs:20794
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndFrame
static void igEndFrame()
Igs the end frame
Alis.Core.Graphic.ImGui.ImGui.TableSetupColumn
static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float initWidthOrWeight)
Tables the setup column using the specified label
Definition: ImGui.cs:20134
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetKeyPressedAmount
static int igGetKeyPressedAmount(ImGuiKey key, float repeatDelay, float rate)
Igs the get key pressed amount using the specified key
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushStyleVar_Vec2
static void igPushStyleVar_Vec2(ImGuiStyleVar idx, Vector2F val)
Igs the push style var vec 2 using the specified idx
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemClicked
static byte igIsItemClicked(ImGuiMouseButton mouseButton)
Igs the is item clicked using the specified mouse button
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginChild_ID
static byte igBeginChild_ID(uint id, Vector2F size, byte border, ImGuiWindowFlags flags)
Igs the begin child id using the specified id
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed)
Describes whether drag scalar n
Definition: ImGui.cs:8424
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnName
static string TableGetColumnName()
Tables the get column name
Definition: ImGui.cs:19884
Alis.Core.Graphic.ImGui.Enums.ImGuiTableBgTarget
ImGuiTableBgTarget
The im gui table bg target enum
Definition: ImGuiTableBgTarget.cs:36
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowDockId
static void SetNextWindowDockId(uint dockId, ImGuiCond cond)
Sets the next window dock id using the specified dock id
Definition: ImGui.cs:16327
Alis.Core.Graphic.ImGui.ImGui.GetItemRectMin
static Vector2F GetItemRectMin()
Gets the item rect min
Definition: ImGui.cs:9340
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v, double step, double stepFast, string format, ImGuiInputTextFlags flags)
Describes whether input double
Definition: ImGui.cs:10327
Alis.Core.Graphic.ImGui.ImGui.ArrowButton
static bool ArrowButton(string strId, ImGuiDir dir)
Describes whether arrow button
Definition: ImGui.cs:140
Alis.Core.Graphic.ImGui.ImGui.LogToTty
static void LogToTty()
Logs the to tty
Definition: ImGui.cs:13470
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize)
Plots the lines using the specified label
Definition: ImGui.cs:14909
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, int v)
Values the prefix
Definition: ImGui.cs:20860
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseClicked_Bool
static byte igIsMouseClicked_Bool(ImGuiMouseButton button, byte repeat)
Igs the is mouse clicked bool using the specified button
Alis.Core.Graphic.ImGui.ImGui.ListBox
static bool ListBox(string label, ref int currentItem, string[] items, int itemsCount, int heightInItems)
Describes whether list box
Definition: ImGui.cs:13163
Alis.Core.Graphic.ImGui.ImGui.GetClipboardText
static string GetClipboardText()
Gets the clipboard text
Definition: ImGui.cs:8940
Alis.Core.Graphic.ImGui.ImGui.PopTextWrapPos
static void PopTextWrapPos()
Pops the text wrap pos
Definition: ImGui.cs:15135
Alis.Core.Graphic.ImGui.Structs.ImGuiPayload
The im gui payload
Definition: ImGuiPayload.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igImage
static void igImage(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol, Vector4F borderCol)
Igs the image using the specified user texture id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopupContextWindow
static byte igBeginPopupContextWindow(byte *strId, ImGuiPopupFlags popupFlags)
Igs the begin popup context window using the specified str id
Alis.Core.Graphic.ImGui.ImGui.BeginTable
static bool BeginTable(string strId, int column, ImGuiTableFlags flags)
Describes whether begin table
Definition: ImGui.cs:1679
Alis.Core.Graphic.ImGui.ImGui.ColorPicker4
static bool ColorPicker4(string label, ref Vector4F col, ImGuiColorEditFlags flags)
Describes whether color picker 4
Definition: ImGui.cs:2762
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed)
Describes whether drag float 3
Definition: ImGui.cs:4402
Alis.Core.Graphic.ImGui.ImGui.SliderFloat4
static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether slider float 4
Definition: ImGui.cs:18322
Alis.Core.Graphic.ImGui.ImGui.IsMouseDragging
static bool IsMouseDragging(ImGuiMouseButton button)
Describes whether is mouse dragging
Definition: ImGui.cs:12754
Alis.Core.Graphic.ImGui.ImGui.Combo
static bool Combo(string label, ref int currentItem, string itemsSeparatedByZeros)
Describes whether combo
Definition: ImGui.cs:3106
Alis.Core.Graphic.ImGui.ImGui.GetColumnOffset
static float GetColumnOffset(int columnIndex)
Gets the column offset using the specified column index
Definition: ImGui.cs:9018
Alis.Core.Graphic.ImGui.Enums.ImGuiSelectableFlags
ImGuiSelectableFlags
The im gui selectable flags enum
Definition: ImGuiSelectableFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.TextUnformatted
static void TextUnformatted(string text)
Texts the unformatted using the specified text
Definition: ImGui.cs:20329
Alis.Core.Graphic.ImGui.ImGui.Columns
static void Columns()
Columnses
Definition: ImGui.cs:2851
Alis.Core.Graphic.ImGui.ImGui.SeparatorText
static void SeparatorText(string label)
Separators the text using the specified label
Definition: ImGui.cs:15917
Alis.Core.Graphic.ImGui.ImGui.IsWindowFocused
static bool IsWindowFocused(ImGuiFocusedFlags flags)
Describes whether is window focused
Definition: ImGui.cs:12985
Alis.Core.Graphic.ImGui.ImGui.IsMouseClicked
static bool IsMouseClicked(ImGuiMouseButton button)
Describes whether is mouse clicked
Definition: ImGui.cs:12707
Alis.Core.Graphic.ImGui.ImGui.EndMenu
static void EndMenu()
Ends the menu
Definition: ImGui.cs:8818
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, float v)
Values the prefix
Definition: ImGui.cs:20934
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollFromPosY_Float
static void igSetScrollFromPosY_Float(float localY, float centerYRatio)
Igs the set scroll from pos y float using the specified local y
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragInt4
static byte igDragInt4(byte *label, int *v, float vSpeed, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the drag int 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.BeginChildFrame
static bool BeginChildFrame(uint id, Vector2F size, ImGuiWindowFlags flags)
Describes whether begin child frame
Definition: ImGui.cs:551
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsRectVisible_Vec2
static byte igIsRectVisible_Vec2(Vector2F rectMin, Vector2F rectMax)
Igs the is rect visible vec 2 using the specified rect min
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, bool enabled)
Describes whether menu item
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCursorPosY
static void igSetCursorPosY(float localY)
Igs the set cursor pos y using the specified local y
Alis.Core.Graphic.ImGui.ImGui.BeginDragDropTarget
static bool BeginDragDropTarget()
Describes whether begin drag drop target
Definition: ImGui.cs:740
Alis.Core.Graphic.ImGui.ImGui.FreeUtf8Bytes
static void FreeUtf8Bytes(byte *utf8Bytes)
Frees the utf 8 bytes using the specified utf 8 bytes
Definition: ImGui.cs:22159
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax)
Plots the histogram using the specified label
Definition: ImGui.cs:14364
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowContentSize
static void SetNextWindowContentSize(Vector2F size)
Sets the next window content size using the specified size
Definition: ImGui.cs:16307
Alis.Core.Graphic.ImGui.ImGui.IsItemActive
static bool IsItemActive()
Describes whether is item active
Definition: ImGui.cs:12545
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSizeConstraints
static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback)
Sets the next window size constraints using the specified size min
Definition: ImGui.cs:16420
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, IntPtr buf, uint bufSize, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
Describes whether input text
Alis.Core.Graphic.ImGui.ImGui.ColorConvertRgBtoHsv
static void ColorConvertRgBtoHsv(float r, float g, float b, out float outH, out float outS, out float outV)
Colors the convert rg bto hsv using the specified r
Definition: ImGui.cs:2420
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float
Definition: ImGui.cs:3766
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, bool selected)
Describes whether selectable
Definition: ImGui.cs:15647
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseDown_Nil
static byte igIsMouseDown_Nil(ImGuiMouseButton button)
Igs the is mouse down nil using the specified button
Alis.Core.Graphic.ImGui.ImGui.IsItemFocused
static bool IsItemFocused()
Describes whether is item focused
Definition: ImGui.cs:12607
Alis.Core.Graphic.ImGui.ImGui.IsMouseDown
static bool IsMouseDown(ImGuiMouseButton button)
Describes whether is mouse down
Definition: ImGui.cs:12743
Alis.Core.Graphic.ImGui.ImGui.SliderInt3
static bool SliderInt3(string label, ref int v, int vMin, int vMax)
Describes whether slider int 3
Definition: ImGui.cs:18827
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndTabBar
static void igEndTabBar()
Igs the end tab bar
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v, float step)
Describes whether input float
Definition: ImGui.cs:10465
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, byte[] buf, uint bufSize, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr userData)
Describes whether input text
Definition: ImGui.cs:21729
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderFloat3
static byte igSliderFloat3(byte *label, Vector3F *v, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the slider float 3 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetItemRectSize
static void igGetItemRectSize(Vector2F *pOut)
Igs the get item rect size using the specified p out
Alis.Core.Graphic.ImGui.ImGui.GetMouseCursor
static ImGuiMouseCursor GetMouseCursor()
Gets the mouse cursor
Definition: ImGui.cs:9418
Alis.Core.Graphic.ImGui.ImGui.Spacing
static void Spacing()
Spacings
Definition: ImGui.cs:19696
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igValue_Int
static void igValue_Int(byte *prefix, int v)
Igs the value int using the specified prefix
Alis.Core.Graphic.ImGui.Enums.ImGuiWindowFlags
ImGuiWindowFlags
The im gui window flags enum
Definition: ImGuiWindowFlags.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemActive
static byte igIsItemActive()
Igs the is item active
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed, int vMin)
Describes whether drag int 4
Definition: ImGui.cs:7157
Alis.Core.Graphic.ImGui.ImGui.PushItemWidth
static void PushItemWidth(float itemWidth)
Pushes the item width using the specified item width
Definition: ImGui.cs:15291
Alis.Core.Graphic.ImGui.ImGui.AreByteArraysEqual
static bool AreByteArraysEqual(byte[] array1, byte[] array2)
Describes whether are byte arrays equal
Definition: ImGui.cs:21978
Alis.Core.Graphic.ImGui.ImGui.SliderInt
static bool SliderInt(string label, ref int v, int vMin, int vMax, string format)
Describes whether slider int
Definition: ImGui.cs:18462
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetTime
static double igGetTime()
Igs the get time
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTextWrapped
static void igTextWrapped(byte *fmt)
Igs the text wrapped using the specified fmt
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCollapsingHeader_TreeNodeFlags
static byte igCollapsingHeader_TreeNodeFlags(byte *label, ImGuiTreeNodeFlags flags)
Igs the collapsing header tree node flags using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetColorU32
static uint GetColorU32(uint col)
Gets the color u 32 using the specified col
Definition: ImGui.cs:8986
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowPos_Str
static void igSetWindowPos_Str(byte *name, Vector2F pos, ImGuiCond cond)
Igs the set window pos str using the specified name
Alis.Core.Graphic.ImGui.ImGui.Columns
static void Columns(int count, string id, bool border)
Columnses the count
Definition: ImGui.cs:2914
Alis.Core.Graphic.ImGui.ImGui.TreePop
static void TreePop()
Trees the pop
Definition: ImGui.cs:20740
Alis.Core.Graphic.ImGui.ImGui.RadioButton
static bool RadioButton(string label, bool active)
Describes whether radio button
Definition: ImGui.cs:15370
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v, double step, double stepFast, string format)
Describes whether input double
Definition: ImGui.cs:10251
Alis.Core.Graphic.ImGui.ImGui.SetColumnWidth
static void SetColumnWidth(int columnIndex, float width)
Sets the column width using the specified column index
Definition: ImGui.cs:16032
Alis.Core.Graphic.ImGui.ImGui.GetMouseDragDelta
static Vector2F GetMouseDragDelta()
Gets the mouse drag delta
Definition: ImGui.cs:9428
Alis.Core.Graphic.ImGui.ImGui.RadioButton
static bool RadioButton(string label, ref int v, int vButton)
Describes whether radio button
Definition: ImGui.cs:15412
Alis.Core.Graphic.ImGui.Enums.ImGuiTableFlags
ImGuiTableFlags
The im gui table flags enum
Definition: ImGuiTableFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax)
Describes whether drag int
Definition: ImGui.cs:5965
Alis.Core.Graphic.ImGui.ImGui.DestroyPlatformWindows
static void DestroyPlatformWindows()
Destroys the platform windows
Definition: ImGui.cs:3370
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowPos
static void SetNextWindowPos(Vector2F pos, ImGuiCond cond)
Sets the next window pos using the specified pos
Definition: ImGui.cs:16356
Alis.Core.Graphic.ImGui.ImGui.SetWindowSize
static void SetWindowSize(string name, Vector2F size)
Sets the window size using the specified name
Definition: ImGui.cs:16898
Alis.Core.Graphic.ImGui.ImGui.IsItemDeactivated
static bool IsItemDeactivated()
Describes whether is item deactivated
Definition: ImGui.cs:12577
Alis.Core.Graphic.ImGui.ImGui.SetColorEditOptions
static void SetColorEditOptions(ImGuiColorEditFlags flags)
Sets the color edit options using the specified flags
Definition: ImGui.cs:16012
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.ImGui.DebugTextEncoding
static void DebugTextEncoding(string text)
Debugs the text encoding using the specified text
Definition: ImGui.cs:3317
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowScroll
static void igSetNextWindowScroll(Vector2F scroll)
Igs the set next window scroll using the specified scroll
Alis.Core
Definition: AudioClip.cs:35
Alis.Core.Graphic.ImGui.Enums.ImGuiCol
ImGuiCol
The im gui col enum
Definition: ImGuiCol.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushStyleVar_Float
static void igPushStyleVar_Float(ImGuiStyleVar idx, float val)
Igs the push style var float using the specified idx
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopStyleColor
static void igPopStyleColor(int count)
Igs the pop style color using the specified count
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogButtons
static void igLogButtons()
Igs the log buttons
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowDebugLogWindow
static void igShowDebugLogWindow(byte *pOpen)
Igs the show debug log window using the specified p open
Alis.Core.Graphic.ImGui.ImGui.BeginListBox
static bool BeginListBox(string label, Vector2F size)
Describes whether begin list box
Definition: ImGui.cs:800
Alis.Core.Graphic.ImGui.ImGui.SetDragDropPayload
static bool SetDragDropPayload(string type, IntPtr data, uint sz)
Describes whether set drag drop payload
Definition: ImGui.cs:16089
Alis.Core.Graphic.ImGui.ImGui.InputInt
static bool InputInt(string label, ref int v, int step, int stepFast, ImGuiInputTextFlags flags)
Describes whether input int
Definition: ImGui.cs:11517
Alis.Core.Graphic.ImGui.ImGui.TableSetupColumn
static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float initWidthOrWeight, uint userId)
Tables the setup column using the specified label
Definition: ImGui.cs:20174
Alis.Core.Graphic.ImGui.ImGui.EndChildFrame
static void EndChildFrame()
Ends the child frame
Definition: ImGui.cs:8746
Alis.Core.Graphic.ImGui.Structs.ImGuiPlatformIo
The im gui platform io
Definition: ImGuiPlatformIO.cs:38
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetItemRectMin
static void igGetItemRectMin(Vector2F *pOut)
Igs the get item rect min using the specified p out
Alis.Core.Graphic.ImGui.ImGui.IsKeyReleased
static bool IsKeyReleased(ImGuiKey key)
Describes whether is key released
Definition: ImGui.cs:12696
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColorU32_Vec4
static uint igGetColorU32_Vec4(Vector4F col)
Igs the get color u 32 vec 4 using the specified col
Alis.Core.Graphic.ImGui.Enums.ImGuiKey
ImGuiKey
The im gui key enum
Definition: ImGuiKey.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopID
static void igPopID()
Igs the pop id
Alis.Core.Graphic.ImGui.ImGui.GetWindowDpiScale
static float GetWindowDpiScale()
Gets the window dpi scale
Definition: ImGui.cs:9663
Alis.Core.Graphic.ImGui.ImGui.Button
static bool Button(string label, Vector2F size)
Describes whether button
Definition: ImGui.cs:1901
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextWindow
static bool BeginPopupContextWindow(string strId, ImGuiPopupFlags popupFlags)
Describes whether begin popup context window
Definition: ImGui.cs:1257
Alis.Core.Graphic.ImGui.ImGui.BeginMenuBar
static bool BeginMenuBar()
Describes whether begin menu bar
Definition: ImGui.cs:929
Alis.Core.Graphic.ImGui.Enums.ImGuiTabItemFlags
ImGuiTabItemFlags
The im gui tab item flags enum
Definition: ImGuiTabItemFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.DockSpaceOverViewport
static uint DockSpaceOverViewport()
Docks the space over viewport
Definition: ImGui.cs:3436
Alis.Core.Graphic.ImGui.ImGui.Combo
static bool Combo(string label, ref int currentItem, string itemsSeparatedByZeros, int popupMaxHeightInItems)
Describes whether combo
Definition: ImGui.cs:3180
Alis.Core.Graphic.ImGui.ImGui.Combo
static bool Combo(string label, ref int currentItem, string[] items, int itemsCount, int popupMaxHeightInItems)
Describes whether combo
Definition: ImGui.cs:3032
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImDrawListPtr
The im draw list ptr
Definition: ImDrawListPtr.cs:42
Alis.Core.Graphic.ImGui.ImGui.SetStateStorage
static void SetStateStorage(ImGuiStoragePtr storage)
Sets the state storage using the specified storage
Definition: ImGui.cs:16546
Alis.Core.Graphic.ImGui.ImGui.InputInt4
static bool InputInt4(string label, ref int v, ImGuiInputTextFlags flags)
Describes whether input int 4
Definition: ImGui.cs:11781
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowAboutWindow
static void igShowAboutWindow(byte *pOpen)
Igs the show about window using the specified p open
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowContentRegionMin
static void igGetWindowContentRegionMin(Vector2F *pOut)
Igs the get window content region min using the specified p out
Alis.Core.Graphic.ImGui.ImGui.GetMouseClickedCount
static int GetMouseClickedCount(ImGuiMouseButton button)
Gets the mouse clicked count using the specified button
Definition: ImGui.cs:9408
Alis.Core.Graphic.ImGui.ImGui.SetKeyboardFocusHere
static void SetKeyboardFocusHere()
Sets the keyboard focus here
Definition: ImGui.cs:16187
Alis.Core.Graphic.ImGui.ImGui.SetWindowSize
static void SetWindowSize(Vector2F size)
Sets the window size using the specified size
Definition: ImGui.cs:16877
Alis.Core.Graphic.ImGui.ImGui.BeginTabBar
static bool BeginTabBar(string strId, ImGuiTabBarFlags flags)
Describes whether begin tab bar
Definition: ImGui.cs:1466
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v, double step)
Describes whether input double
Definition: ImGui.cs:10117
Alis.Core.Graphic.ImGui.ImGui.InputTextWithHint
static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr userData)
Describes whether input text with hint
Definition: ImGui.cs:22061
Alis.Core.Graphic.ImGui.ImGui.SliderInt4
static bool SliderInt4(string label, ref int v, int vMin, int vMax)
Describes whether slider int 4
Definition: ImGui.cs:19043
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndChild
static void igEndChild()
Igs the end child
Alis.Core.Graphic.ImGui.ImGui.SetCursorPosY
static void SetCursorPosY(float localY)
Sets the cursor pos y using the specified local y
Definition: ImGui.cs:16068
Alis.Core.Graphic.ImGui.ImGui.GetColorU32
static uint GetColorU32(ImGuiCol idx)
Gets the color u 32 using the specified idx
Definition: ImGui.cs:8951
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v, float step, float stepFast, string format)
Describes whether input float
Definition: ImGui.cs:10599
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v)
Describes whether drag float 2
Definition: ImGui.cs:3914
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopButtonRepeat
static void igPopButtonRepeat()
Igs the pop button repeat
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputTextMultiline
static byte igInputTextMultiline(byte *label, byte *buf, uint bufSize, Vector2F size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void *userData)
Igs the input text multiline using the specified label
Alis.Core.Graphic.ImGui.ImGui.ColorPicker4
static bool ColorPicker4(string label, ref Vector4F col, ImGuiColorEditFlags flags, ref float refCol)
Describes whether color picker 4
Definition: ImGui.cs:2808
Alis.Core.Graphic.ImGui.ImGui.GetFrameHeightWithSpacing
static float GetFrameHeightWithSpacing()
Gets the frame height with spacing
Definition: ImGui.cs:9248
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetColumnIndex
static byte igTableSetColumnIndex(int columnN)
Igs the table set column index using the specified column n
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsKeyDown_Nil
static byte igIsKeyDown_Nil(ImGuiKey key)
Igs the is key down nil using the specified key
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0)
Images the user texture id
Definition: ImGui.cs:9751
Alis.Core.Graphic.ImGui.ImGui.GetFrameHeight
static float GetFrameHeight()
Gets the frame height
Definition: ImGui.cs:9238
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetForegroundDrawList_Nil
static ImDrawList * igGetForegroundDrawList_Nil()
Igs the get foreground draw list nil
Alis.Core.Graphic.ImGui.ImGui.VSliderFloat
static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax)
Describes whether v slider float
Definition: ImGui.cs:21042
Alis.Core.Graphic.ImGui.ImGui.PushStyleVar
static void PushStyleVar(ImGuiStyleVar idx, float val)
Pushes the style var using the specified idx
Definition: ImGui.cs:15321
Alis.Core.Graphic.ImGui.ImGui.AlignTextToFramePadding
static void AlignTextToFramePadding()
Aligns the text to frame padding
Definition: ImGui.cs:129
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetClipboardText
static byte * igGetClipboardText()
Igs the get clipboard text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollHereY
static void igSetScrollHereY(float centerYRatio)
Igs the set scroll here y using the specified center y ratio
Alis.Core.Graphic.ImGui.ImGui.IsWindowAppearing
static bool IsWindowAppearing()
Describes whether is window appearing
Definition: ImGui.cs:12943
Alis.Core.Graphic.ImGui.ImGui.ColorConvertHsVtoRgb
static void ColorConvertHsVtoRgb(float h, float s, float v, out float outR, out float outG, out float outB)
Colors the convert hs vto rgb using the specified h
Definition: ImGui.cs:2397
Alis.Core.Graphic.ImGui.Delegates.ImGuiSizeCallback
unsafe delegate void ImGuiSizeCallback(ImGuiSizeCallbackData *data)
The im gui size callback
Alis.Core.Graphic.ImGui.ImGui.GetFrameCount
static int GetFrameCount()
Gets the frame count
Definition: ImGui.cs:9228
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemHovered
static byte igIsItemHovered(ImGuiHoveredFlags flags)
Igs the is item hovered using the specified flags
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igOpenPopupOnItemClick
static void igOpenPopupOnItemClick(byte *strId, ImGuiPopupFlags popupFlags)
Igs the open popup on item click using the specified str id
Alis
Definition: Engine.cs:31
Alis.Core.Graphic.ImGui.ImGui.BeginPopupModal
static bool BeginPopupModal(string name)
Describes whether begin popup modal
Definition: ImGui.cs:1296
Alis.Core.Graphic.ImGui.ImGui.GetBackgroundDrawList
static ImDrawListPtr GetBackgroundDrawList(ImGuiViewportPtr viewport)
Gets the background draw list using the specified viewport
Definition: ImGui.cs:8929
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowFontSelector
static void igShowFontSelector(byte *label)
Igs the show font selector using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetWindowContentRegionMin
static Vector2F GetWindowContentRegionMin()
Gets the window content region min
Definition: ImGui.cs:9642
Alis.Core.Graphic.ImGui.ImGui.SetNextFrameWantCaptureKeyboard
static void SetNextFrameWantCaptureKeyboard(bool wantCaptureKeyboard)
Sets the next frame want capture keyboard using the specified want capture keyboard
Definition: ImGui.cs:16215
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextFrameWantCaptureKeyboard
static void igSetNextFrameWantCaptureKeyboard(byte wantCaptureKeyboard)
Igs the set next frame want capture keyboard using the specified want capture keyboard
Alis.Core.Graphic.ImGui.ImGui.InputTextMultiline
static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2F size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr userData)
Determines whether the input text is multiline.
Definition: ImGui.cs:21923
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax)
Describes whether drag float 2
Definition: ImGui.cs:4118
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igArrowButton
static byte igArrowButton(byte *strId, ImGuiDir dir)
Igs the arrow button using the specified str id
Alis.Core.Graphic.ImGui.ImGui.TableSetupColumn
static void TableSetupColumn(string label)
Tables the setup column using the specified label
Definition: ImGui.cs:20054
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount)
Plots the lines using the specified label
Definition: ImGui.cs:14585
Alis.Core.Graphic.ImGui.ImGui.GetFontSize
static float GetFontSize()
Gets the font size
Definition: ImGui.cs:9185
Alis.Core.Graphic.ImGui.ImGui.EndDragDropSource
static void EndDragDropSource()
Ends the drag drop source
Definition: ImGui.cs:8770
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(uint id, Vector2F size)
Describes whether begin child
Definition: ImGui.cs:493
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol)
Describes whether image button
Definition: ImGui.cs:9946
Alis.Core.Graphic.ImGui.ImGui.SetWindowSize
static void SetWindowSize(Vector2F size, ImGuiCond cond)
Sets the window size using the specified size
Definition: ImGui.cs:16888
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSize
static void SetNextWindowSize(Vector2F size, ImGuiCond cond)
Sets the next window size using the specified size
Definition: ImGui.cs:16397
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igFindViewportByPlatformHandle
static ImGuiViewport * igFindViewportByPlatformHandle(void *platformHandle)
Igs the find viewport by platform handle using the specified platform handle
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v)
Describes whether drag int 2
Definition: ImGui.cs:6181
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowCollapsed_Bool
static void igSetWindowCollapsed_Bool(byte collapsed, ImGuiCond cond)
Igs the set window collapsed bool using the specified collapsed
Alis.Core.Graphic.ImGui.ImGui.GetStyleColorName
static string GetStyleColorName(ImGuiCol idx)
Gets the style color name using the specified idx
Definition: ImGui.cs:9560
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloat
static byte igDragFloat(byte *label, float *v, float vSpeed, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the drag float using the specified label
Alis.Core.Graphic.ImGui.Enums.ImGuiDragDropFlags
ImGuiDragDropFlags
The im gui drag drop flags enum
Definition: ImGuiDragDropFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.StyleColorsLight
static void StyleColorsLight(ImGuiStylePtr dst)
Styles the colors light using the specified dst
Definition: ImGui.cs:19752
Alis.Core.Graphic.ImGui.ImGui.ShowDebugLogWindow
static void ShowDebugLogWindow(ref bool pOpen)
Shows the debug log window using the specified p open
Definition: ImGui.cs:17003
Alis.Core.Graphic.ImGui.ImGui.InputInt2
static bool InputInt2(string label, ref int v, ImGuiInputTextFlags flags)
Describes whether input int 2
Definition: ImGui.cs:11605
Alis.Core.Graphic.ImGui.ImGui.PopButtonRepeat
static void PopButtonRepeat()
Pops the button repeat
Definition: ImGui.cs:15051
Alis.Core.Graphic.ImGui.ImGui.BeginGroup
static void BeginGroup()
Begins the group
Definition: ImGui.cs:749
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format, string formatMax)
Describes whether drag float range 2
Definition: ImGui.cs:5549
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMainViewport
static ImGuiViewport * igGetMainViewport()
Igs the get main viewport
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igImageButton
static byte igImageButton(byte *strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol, Vector4F tintCol)
Igs the image button using the specified str id
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax)
Describes whether drag float 4
Definition: ImGui.cs:4958
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushFont
static void igPushFont(ImFont *font)
Igs the push font using the specified font
Alis.Core.Graphic.ImGui.ImGui.SetWindowSize
static void SetWindowSize(string name, Vector2F size, ImGuiCond cond)
Sets the window size using the specified name
Definition: ImGui.cs:16937
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep)
Describes whether input scalar
Definition: ImGui.cs:11872
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, IntPtr buf, uint bufSize, ImGuiInputTextFlags flags)
Describes whether input text
Alis.Core.Graphic.ImGui.Enums.ImGuiMouseCursor
ImGuiMouseCursor
The im gui mouse cursor enum
Definition: ImGuiMouseCursor.cs:36
Alis.Core.Graphic.ImGui.ImGui.SetWindowCollapsed
static void SetWindowCollapsed(string name, bool collapsed)
Sets the window collapsed using the specified name
Definition: ImGui.cs:16651
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igVSliderInt
static byte igVSliderInt(byte *label, Vector2F size, int *v, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the v slider int using the specified label
Alis.Core.Graphic.ImGui.ImGui.IsAnyItemHovered
static bool IsAnyItemHovered()
Describes whether is any item hovered
Definition: ImGui.cs:12515
Alis.Core.Graphic.ImGui.ImGui.SetScrollFromPosY
static void SetScrollFromPosY(float localY)
Sets the scroll from pos y using the specified local y
Definition: ImGui.cs:16472
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igValue_Bool
static void igValue_Bool(byte *prefix, byte b)
Igs the value bool using the specified prefix
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputFloat4
static byte igInputFloat4(byte *label, Vector4F *v, byte *format, ImGuiInputTextFlags flags)
Igs the input float 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.AcceptDragDropPayload
static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDropFlags flags)
Accepts the drag drop payload using the specified type
Definition: ImGui.cs:92
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDebugCheckVersionAndDataLayout
static byte igDebugCheckVersionAndDataLayout(byte *versionStr, uint szIo, uint szStyle, uint szVec2, uint szVec4, uint szDrawvert, uint szDrawidx)
Igs the debug check version and data layout using the specified version str
Alis.Core.Aspect.Math.Vector
Definition: Vector2B.cs:33
Alis.Core.Graphic.ImGui.Enums.ImGuiSliderFlags
ImGuiSliderFlags
The im gui slider flags enum
Definition: ImGuiSliderFlags.cs:39
Alis.Core.Graphic.ImGui.Structs.ImDrawDataPtr
The im draw data ptr
Definition: ImDrawDataPtr.cs:40
Alis.Core.Graphic.ImGui.ImGui.SetWindowPos
static void SetWindowPos(string name, Vector2F pos)
Sets the window pos using the specified name
Definition: ImGui.cs:16802
Alis.Core.Graphic.ImGui.ImGui.SliderFloat3
static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax, string format)
Describes whether slider float 3
Definition: ImGui.cs:18030
Alis.Core.Graphic.ImGui.ImGui.EndGroup
static void EndGroup()
Ends the group
Definition: ImGui.cs:8794
Alis.Core.Graphic.ImGui.Structs.ImGuiIoPtr
The im gui io ptr
Definition: ImGuiIOPtr.cs:42
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableHeadersRow
static void igTableHeadersRow()
Igs the table headers row
Alis.Core.Graphic.ImGui.ImGui.EndMenuBar
static void EndMenuBar()
Ends the menu bar
Definition: ImGui.cs:8826
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags)
Describes whether selectable
Definition: ImGui.cs:15691
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetRowIndex
static int igTableGetRowIndex()
Igs the table get row index
Alis.Core.Graphic.ImGui.ImGui.StyleColorsClassic
static void StyleColorsClassic(ImGuiStylePtr dst)
Styles the colors classic using the specified dst
Definition: ImGui.cs:19714
Alis.Core.Graphic.ImGui.ImGui.PushId
static void PushId(int intId)
Pushes the id using the specified int id
Definition: ImGui.cs:15282
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igVSliderFloat
static byte igVSliderFloat(byte *label, Vector2F size, float *v, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the v slider float using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderInt4
static bool SliderInt4(string label, ref int v, int vMin, int vMax, string format)
Describes whether slider int 4
Definition: ImGui.cs:19110
Alis.Core.Graphic.ImGui.ImGui.Separator
static void Separator()
Separators
Definition: ImGui.cs:15908
Alis.Core.Graphic.ImGui.ImGui.LogToClipboard
static void LogToClipboard()
Logs the to clipboard
Definition: ImGui.cs:13395
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBullet
static void igBullet()
Igs the bullet
Alis.Core.Graphic.ImGui.ImGui.AcceptDragDropPayload
static ImGuiPayloadPtr AcceptDragDropPayload(string type)
Accepts the drag drop payload using the specified type
Definition: ImGui.cs:51
Alis.Core.Graphic.ImGui.ImGui.CreateContext
static IntPtr CreateContext()
Creates the context
Definition: ImGui.cs:3249
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSizeConstraints
static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax)
Sets the next window size constraints using the specified size min
Definition: ImGui.cs:16407
Alis.Core.Graphic.ImGui.ImGui.BeginPopup
static bool BeginPopup(string strId, ImGuiWindowFlags flags)
Describes whether begin popup
Definition: ImGui.cs:981
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetColumnEnabled
static void igTableSetColumnEnabled(int columnN, byte v)
Igs the table set column enabled using the specified column n
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut, bool selected)
Describes whether menu item
Definition: ImGui.cs:13625
Alis.Core.Graphic.ImGui.ImGui.InputTextWithHint
static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength)
Describes whether input text with hint
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax, string format)
Describes whether drag scalar n
Definition: ImGui.cs:8574
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetColumnOffset
static void igSetColumnOffset(int columnIndex, float offsetX)
Igs the set column offset using the specified column index
Alis.Core.Graphic.ImGui.Utils
Definition: Unsafe.cs:36
Alis.Core.Graphic.ImGui.Structs.ImFontPtr.NativePtr
ImFont * NativePtr
Gets the value of the native ptr
Definition: ImFontPtr.cs:44
Alis.Core.Graphic.ImGui.Utils.Util.Allocate
static byte * Allocate(int byteCount)
Allocates the byte count
Alis.Core.Graphic.ImGui.ImGui.StyleColorsClassic
static void StyleColorsClassic()
Styles the colors classic
Definition: ImGui.cs:19704
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetBackgroundDrawList_ViewportPtr
static ImDrawList * igGetBackgroundDrawList_ViewportPtr(ImGuiViewport *viewport)
Igs the get background draw list viewport ptr using the specified viewport
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndGroup
static void igEndGroup()
Igs the end group
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFontSize
static float igGetFontSize()
Igs the get font size
Alis.Core.Graphic.ImGui.ImGui.End
static void End()
Ends
Definition: ImGui.cs:8730
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igAcceptDragDropPayload
static ImGuiPayload * igAcceptDragDropPayload(byte *type, ImGuiDragDropFlags flags)
Igs the accept drag drop payload using the specified type
Alis.Core.Graphic.ImGui.ImGui.IsWindowCollapsed
static bool IsWindowCollapsed()
Describes whether is window collapsed
Definition: ImGui.cs:12953
Alis.Core.Graphic.ImGui.ImGui.DestroyContext
static void DestroyContext()
Destroys the context
Definition: ImGui.cs:3352
Alis.Core.Graphic.ImGui.ImGui.BeginListBox
static bool BeginListBox(string label)
Describes whether begin list box
Definition: ImGui.cs:759
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetKeyName
static byte * igGetKeyName(ImGuiKey key)
Igs the get key name using the specified key
Alis.Core.Graphic.ImGui.ImGui.InputFloat3
static bool InputFloat3(string label, ref Vector3F v, string format)
Describes whether input float 3
Definition: ImGui.cs:11021
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetAllocatorFunctions
static void igGetAllocatorFunctions(IntPtr *pAllocFunc, IntPtr *pFreeFunc, void **pUserData)
Igs the get allocator functions using the specified p alloc func
Alis.Core.Graphic.ImGui.ImGui.BeginTabItem
static bool BeginTabItem(string label, ref bool pOpen)
Describes whether begin tab item
Definition: ImGui.cs:1547
Alis.Core.Graphic.ImGui.Enums.ImGuiTabBarFlags
ImGuiTabBarFlags
The im gui tab bar flags enum
Definition: ImGuiTabBarFlags.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCurrentContext
static IntPtr igGetCurrentContext()
Igs the get current context
Alis.Core.Graphic.ImGui.ImGui.GetColorU32
static uint GetColorU32(Vector4F col)
Gets the color u 32 using the specified col
Definition: ImGui.cs:8975
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut, ref bool pSelected, bool enabled)
Describes whether menu item
Definition: ImGui.cs:13842
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemEdited
static byte igIsItemEdited()
Igs the is item edited
Alis.Core.Graphic.ImGui.ImGui.GetColumnOffset
static float GetColumnOffset()
Gets the column offset
Definition: ImGui.cs:9006
Alis.Core.Graphic.ImGui.ImGui.SetMouseCursor
static void SetMouseCursor(ImGuiMouseCursor cursorType)
Sets the mouse cursor using the specified cursor type
Definition: ImGui.cs:16206
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetStateStorage
static ImGuiStorage * igGetStateStorage()
Igs the get state storage
Alis.Core.Graphic.ImGui
Definition: NonVersionableAttribute.cs:33
Alis.Core.Graphic.ImGui.ImGui.IsItemToggledOpen
static bool IsItemToggledOpen()
Describes whether is item toggled open
Definition: ImGui.cs:12639
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v, float step, float stepFast, string format, ImGuiInputTextFlags flags)
Describes whether input float
Definition: ImGui.cs:10675
Alis.Core.Graphic.ImGui.ImGui.SliderScalarN
static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax, string format)
Describes whether slider scalar n
Definition: ImGui.cs:19511
Alis.Core.Graphic.ImGui.Structs.ImGuiNative
The im gui native class
Definition: ImGuiNative.cs:42
Alis.Core.Graphic.ImGui.Utils.Util
The util class
Definition: Util.cs:40
Alis.Core.Graphic.ImGui.ImGui.TableSetBgColor
static void TableSetBgColor(ImGuiTableBgTarget target, uint color)
Tables the set bg color using the specified target
Definition: ImGui.cs:20011
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowFontScale
static void igSetWindowFontScale(float scale)
Igs the set window font scale using the specified scale
Alis.Core.Graphic.ImGui.ImGui.PushFont
static void PushFont(ImFontPtr font)
Pushes the font using the specified font
Definition: ImGui.cs:15226
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopupContextItem
static byte igBeginPopupContextItem(byte *strId, ImGuiPopupFlags popupFlags)
Igs the begin popup context item using the specified str id
Alis.Core.Graphic.ImGui.ImGui.SetNextItemOpen
static void SetNextItemOpen(bool isOpen, ImGuiCond cond)
Sets the next item open using the specified is open
Definition: ImGui.cs:16247
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igRenderPlatformWindowsDefault
static void igRenderPlatformWindowsDefault(void *platformRenderArg, void *rendererRenderArg)
Igs the render platform windows default using the specified platform render arg
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushID_Int
static void igPushID_Int(int intId)
Igs the push id int using the specified int id
Alis.Core.Graphic.ImGui.ImGui.IsRectVisible
static bool IsRectVisible(Vector2F rectMin, Vector2F rectMax)
Describes whether is rect visible
Definition: ImGui.cs:12933
Alis.Core.Graphic.ImGui.ImGui.GetWindowDockId
static uint GetWindowDockId()
Gets the window dock id
Definition: ImGui.cs:9653
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetColumnIndex
static int igTableGetColumnIndex()
Igs the table get column index
Alis.Core.Graphic.ImGui.ImGui.InputInt
static bool InputInt(string label, ref int v)
Describes whether input int
Definition: ImGui.cs:11376
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetScrollY
static float igGetScrollY()
Igs the get scroll y
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetTextLineHeightWithSpacing
static float igGetTextLineHeightWithSpacing()
Igs the get text line height with spacing
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed)
Describes whether drag int 4
Definition: ImGui.cs:7089
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed)
Describes whether drag int 3
Definition: ImGui.cs:6669
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginChildFrame
static byte igBeginChildFrame(uint id, Vector2F size, ImGuiWindowFlags flags)
Igs the begin child frame using the specified id
Alis.Core.Graphic.ImGui.ImGui.VSliderInt
static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax)
Describes whether v slider int
Definition: ImGui.cs:21261
Alis.Core.Graphic.ImGui.ImGui.SliderInt2
static bool SliderInt2(string label, ref int v, int vMin, int vMax)
Describes whether slider int 2
Definition: ImGui.cs:18611
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut, bool selected, bool enabled)
Describes whether menu item
Definition: ImGui.cs:13697
Alis.Core.Graphic.ImGui.ImGui.Text
static void Text(string fmt)
Texts the fmt
Definition: ImGui.cs:20220
Alis.Core.Graphic.ImGui.ImGui.SetTooltip
static void SetTooltip(string fmt)
Sets the tooltip using the specified fmt
Definition: ImGui.cs:16592
Alis.Core.Graphic.ImGui.ImGui.TabItemButton
static bool TabItemButton(string label)
Describes whether tab item button
Definition: ImGui.cs:19763
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetBackgroundDrawList_Nil
static ImDrawList * igGetBackgroundDrawList_Nil()
Igs the get background draw list nil
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushID_Ptr
static void igPushID_Ptr(void *ptrId)
Igs the push id ptr using the specified ptr id
Alis.Core.Graphic.ImGui.ImGui.SetCursorPos
static void SetCursorPos(Vector2F localPos)
Sets the cursor pos using the specified local pos
Definition: ImGui.cs:16050
Alis.Core.Graphic.ImGui.ImGui.SetScrollFromPosX
static void SetScrollFromPosX(float localX)
Sets the scroll from pos x using the specified local x
Definition: ImGui.cs:16452
Alis.Core.Graphic.ImGui.ImGui.SetNextItemWidth
static void SetNextItemWidth(float itemWidth)
Sets the next item width using the specified item width
Definition: ImGui.cs:16257
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowViewport
static void SetNextWindowViewport(uint viewportId)
Sets the next window viewport using the specified viewport id
Definition: ImGui.cs:16443
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igAlignTextToFramePadding
static void igAlignTextToFramePadding()
Igs the align text to frame padding
Alis.Core.Graphic.ImGui.Structs.ImGuiViewportPtr
The im gui viewport ptr
Definition: ImGuiViewportPtr.cs:41
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopFont
static void igPopFont()
Igs the pop font
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndTooltip
static void igEndTooltip()
Igs the end tooltip
Alis.Core.Graphic.ImGui.ImGui.IsItemActivated
static bool IsItemActivated()
Describes whether is item activated
Definition: ImGui.cs:12535
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin)
Describes whether drag float range 2
Definition: ImGui.cs:5321
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCollapsingHeader_BoolPtr
static byte igCollapsingHeader_BoolPtr(byte *label, byte *pVisible, ImGuiTreeNodeFlags flags)
Igs the collapsing header bool ptr using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowDpiScale
static float igGetWindowDpiScale()
Igs the get window dpi scale
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTabItemButton
static byte igTabItemButton(byte *label, ImGuiTabItemFlags flags)
Igs the tab item button using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetContentRegionAvail
static Vector2F GetContentRegionAvail()
Gets the content region avail
Definition: ImGui.cs:9060
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetStyleColorVec4
static Vector4F * igGetStyleColorVec4(ImGuiCol idx)
Igs the get style color vec 4 using the specified idx
Alis.Core.Graphic.ImGui.ImGui.DestroyContext
static void DestroyContext(IntPtr ctx)
Destroys the context using the specified ctx
Definition: ImGui.cs:3362
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLoadIniSettingsFromMemory
static void igLoadIniSettingsFromMemory(byte *iniData, uint iniSize)
Igs the load ini settings from memory using the specified ini data
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableNextRow
static void igTableNextRow(ImGuiTableRowFlags rowFlags, float minRowHeight)
Igs the table next row using the specified row flags
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep)
Describes whether input scalar n
Definition: ImGui.cs:12167
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorEdit3
static byte igColorEdit3(byte *label, Vector3F *col, ImGuiColorEditFlags flags)
Igs the color edit 3 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowSize_Str
static void igSetWindowSize_Str(byte *name, Vector2F size, ImGuiCond cond)
Igs the set window size str using the specified name
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogText
static void igLogText(byte *fmt)
Igs the log text using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.ShowDemoWindow
static void ShowDemoWindow(ref bool pOpen)
Shows the demo window using the specified p open
Definition: ImGui.cs:17024
Alis.Core.Graphic.ImGui.ImGui.ProgressBar
static void ProgressBar(float fraction, Vector2F sizeArg, string overlay)
Progresses the bar using the specified fraction
Definition: ImGui.cs:15168
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igStyleColorsDark
static void igStyleColorsDark(ImGuiStyle *dst)
Igs the style colors dark using the specified dst
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDummy
static void igDummy(Vector2F size)
Igs the dummy using the specified size
Alis.Core.Graphic.ImGui.ImGui.TableGetRowIndex
static int TableGetRowIndex()
Tables the get row index
Definition: ImGui.cs:19906
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsAnyItemHovered
static byte igIsAnyItemHovered()
Igs the is any item hovered
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igStyleColorsLight
static void igStyleColorsLight(ImGuiStyle *dst)
Igs the style colors light using the specified dst
Alis.Core.Graphic.ImGui.ImGui.TreeNodeEx
static bool TreeNodeEx(string label, ImGuiTreeNodeFlags flags)
Describes whether tree node ex
Definition: ImGui.cs:20592
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, byte[] buf, uint bufSize)
Alis.Core.Graphic.ImGui.ImGui.SetCursorPosX
static void SetCursorPosX(float localX)
Sets the cursor pos x using the specified local x
Definition: ImGui.cs:16059
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, int length)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.ImGui.CollapsingHeader
static bool CollapsingHeader(string label, ImGuiTreeNodeFlags flags)
Describes whether collapsing header
Definition: ImGui.cs:2130
Alis.Core.Graphic.ImGui.ImGui.PushTextWrapPos
static void PushTextWrapPos(float wrapLocalPosX)
Pushes the text wrap pos using the specified wrap local pos x
Definition: ImGui.cs:15359
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax)
Describes whether drag float 3
Definition: ImGui.cs:4538
Alis.Core.Graphic.ImGui.ImGui.ColorConvertU32ToFloat4
static Vector4F ColorConvertU32ToFloat4(uint @in)
/
Definition: ImGui.cs:2439
Alis.Core.Graphic.ImGui.ImGui.PopStyleVar
static void PopStyleVar()
Pops the style var
Definition: ImGui.cs:15109
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol)
Images the user texture id
Definition: ImGui.cs:9781
Alis.Core.Graphic.ImGui.ImGui.GetScrollX
static float GetScrollX()
Gets the scroll x
Definition: ImGui.cs:9519
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetMouseCursor
static void igSetMouseCursor(ImGuiMouseCursor cursorType)
Igs the set mouse cursor using the specified cursor type
Alis.Core.Graphic.ImGui.ImGui.TreeNodeEx
static bool TreeNodeEx(IntPtr ptrId, ImGuiTreeNodeFlags flags, string fmt)
Describes whether tree node ex
Definition: ImGui.cs:20702
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v, double step, double stepFast)
Describes whether input double
Definition: ImGui.cs:10184
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax)
Describes whether drag int 4
Definition: ImGui.cs:7225
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igNewFrame
static void igNewFrame()
Igs the new frame
Alis.Core.Graphic.ImGui.ImGui.GetCurrentContext
static IntPtr GetCurrentContext()
Gets the current context
Definition: ImGui.cs:9082
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether drag int 4
Definition: ImGui.cs:7370
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText)
Plots the lines using the specified label
Definition: ImGui.cs:14681
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetDrawListSharedData
static IntPtr igGetDrawListSharedData()
Igs the get draw list shared data
Alis.Core.Graphic.ImGui.ImGui.GetMainViewport
static ImGuiViewportPtr GetMainViewport()
Gets the main viewport
Definition: ImGui.cs:9397
Alis.Core.Graphic.ImGui.ImGui.NewLine
static void NewLine()
News the line
Definition: ImGui.cs:13919
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorPicker4
static byte igColorPicker4(byte *label, Vector4F *col, ImGuiColorEditFlags flags, float *refCol)
Igs the color picker 4 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndMenuBar
static void igEndMenuBar()
Igs the end menu bar
Alis.Core.Graphic.ImGui.ImGui.SetScrollY
static void SetScrollY(float scrollY)
Sets the scroll y using the specified scroll y
Definition: ImGui.cs:16537
Alis.Core.Graphic.ImGui.ImGui.SetWindowFocus
static void SetWindowFocus()
Sets the window focus
Definition: ImGui.cs:16727
Alis.Core.Graphic.ImGui.ImGui.SetWindowCollapsed
static void SetWindowCollapsed(string name, bool collapsed, ImGuiCond cond)
Sets the window collapsed using the specified name
Definition: ImGui.cs:16691
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCheckboxFlags_IntPtr
static byte igCheckboxFlags_IntPtr(byte *label, int *flags, int flagsValue)
Igs the checkbox flags int ptr using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetClipboardText
static void igSetClipboardText(byte *text)
Igs the set clipboard text using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopTextWrapPos
static void igPopTextWrapPos()
Igs the pop text wrap pos
Alis.Core.Graphic.ImGui.ImGui.CalcItemWidth
static float CalcItemWidth()
Calcs the item width
Definition: ImGui.cs:1939
Alis.Core.Graphic.ImGui.ImGui.InputInt4
static bool InputInt4(string label, ref int v)
Describes whether input int 4
Definition: ImGui.cs:11736
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsKeyPressed_Bool
static byte igIsKeyPressed_Bool(ImGuiKey key, byte repeat)
Igs the is key pressed bool using the specified key
Alis.Core.Graphic.ImGui.ImGui.GetForegroundDrawList
static ImDrawListPtr GetForegroundDrawList(ImGuiViewportPtr viewport)
Gets the foreground draw list using the specified viewport
Definition: ImGui.cs:9217
Alis.Core.Graphic.ImGui.ImGui.GetDragDropPayload
static ImGuiPayloadPtr GetDragDropPayload()
Gets the drag drop payload
Definition: ImGui.cs:9145
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorPicker3
static byte igColorPicker3(byte *label, Vector3F *col, ImGuiColorEditFlags flags)
Igs the color picker 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetItemRectMax
static Vector2F GetItemRectMax()
Gets the item rect max
Definition: ImGui.cs:9329
Alis.Core.Graphic.ImGui.ImGui.OpenPopupOnItemClick
static void OpenPopupOnItemClick(string strId, ImGuiPopupFlags popupFlags)
Opens the popup on item click using the specified str id
Definition: ImGui.cs:14078
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndDragDropSource
static void igEndDragDropSource()
Igs the end drag drop source
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax)
Describes whether drag int range 2
Definition: ImGui.cs:7661
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, bool hideTextAfterDoubleHash)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiTableSortSpecsPtr
The im gui table sort specs ptr
Definition: ImGuiTableSortSpecsPtr.cs:39
Alis.Core.Graphic.ImGui.ImGui.GetAllocatorFunctions
static void GetAllocatorFunctions(ref IntPtr pAllocFunc, ref IntPtr pFreeFunc, ref void *pUserData)
Gets the allocator functions using the specified p alloc func
Definition: ImGui.cs:8900
Alis.Core.Graphic.ImGui.ImGui.SetWindowCollapsed
static void SetWindowCollapsed(bool collapsed)
Sets the window collapsed using the specified collapsed
Definition: ImGui.cs:16628
Alis.Core.Graphic.ImGui.ImGui.GetMousePosOnOpeningCurrentPopup
static Vector2F GetMousePosOnOpeningCurrentPopup()
Gets the mouse pos on opening current popup
Definition: ImGui.cs:9478
Alis.Core.Graphic.ImGui.ImGui.GetCursorStartPos
static Vector2F GetCursorStartPos()
Gets the cursor start pos
Definition: ImGui.cs:9134
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextItemWidth
static void igSetNextItemWidth(float itemWidth)
Igs the set next item width using the specified item width
Alis.Core.Graphic.ImGui.ImGui.GetColorU32
static uint GetColorU32(ImGuiCol idx, float alphaMul)
Gets the color u 32 using the specified idx
Definition: ImGui.cs:8964
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igMemAlloc
static void * igMemAlloc(uint size)
Igs the mem alloc using the specified size
Alis.Core.Graphic.ImGui.Utils.Util.StringFromPtr
static string StringFromPtr(byte *ptr)
Strings the from ptr using the specified ptr
Definition: Util.cs:51
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetTreeNodeToLabelSpacing
static float igGetTreeNodeToLabelSpacing()
Igs the get tree node to label spacing
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetDrawData
static ImDrawData * igGetDrawData()
Igs the get draw data
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorConvertFloat4ToU32
static uint igColorConvertFloat4ToU32(Vector4F @in)
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetItemAllowOverlap
static void igSetItemAllowOverlap()
Igs the set item allow overlap
Alis.Core.Graphic.ImGui.ImGui.ShowAboutWindow
static void ShowAboutWindow(ref bool pOpen)
Shows the about window using the specified p open
Definition: ImGui.cs:16982
Alis.Core.Graphic.ImGui.Enums
Definition: ImDrawFlags.cs:33
Alis.Core.Graphic.ImGui.ImGui.ColorConvertFloat4ToU32
static uint ColorConvertFloat4ToU32(Vector4F @in)
Definition: ImGui.cs:2382
Alis.Core.Graphic.ImGui.ImGui.BeginTooltip
static bool BeginTooltip()
Describes whether begin tooltip
Definition: ImGui.cs:1805
Alis.Core.Graphic.ImGui.ImGui.IsMouseHoveringRect
static bool IsMouseHoveringRect(Vector2F rMin, Vector2F rMax, bool clip)
Describes whether is mouse hovering rect
Definition: ImGui.cs:12793
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(uint id)
Describes whether begin child
Definition: ImGui.cs:478
Alis.Core.Graphic.ImGui.ImGui.SetScrollHereY
static void SetScrollHereY()
Sets the scroll here y
Definition: ImGui.cs:16509
Alis.Core.Graphic.ImGui.ImGui.GetFont
static ImFontPtr GetFont()
Gets the font
Definition: ImGui.cs:9175
Alis.Core.Graphic.ImGui.ImGui.SetCursorScreenPos
static void SetCursorScreenPos(Vector2F pos)
Sets the cursor screen pos using the specified pos
Definition: ImGui.cs:16077
Alis.Core.Graphic.ImGui.ImGui.SliderInt
static bool SliderInt(string label, ref int v, int vMin, int vMax)
Describes whether slider int
Definition: ImGui.cs:18395
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextWindow
static bool BeginPopupContextWindow(string strId)
Describes whether begin popup context window
Definition: ImGui.cs:1216
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax, string format)
Describes whether slider angle
Definition: ImGui.cs:17382
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemDeactivatedAfterEdit
static byte igIsItemDeactivatedAfterEdit()
Igs the is item deactivated after edit
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(string strId, Vector2F size, bool border, ImGuiWindowFlags flags)
Describes whether begin child
Definition: ImGui.cs:438
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, int length, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndCombo
static void igEndCombo()
Igs the end combo
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragScalar
static byte igDragScalar(byte *label, ImGuiDataType dataType, void *pData, float vSpeed, void *pMin, void *pMax, byte *format, ImGuiSliderFlags flags)
Igs the drag scalar using the specified label
Alis.Core.Graphic.ImGui.ImGui.IsMouseDoubleClicked
static bool IsMouseDoubleClicked(ImGuiMouseButton button)
Describes whether is mouse double clicked
Definition: ImGui.cs:12732
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseHoveringRect
static byte igIsMouseHoveringRect(Vector2F rMin, Vector2F rMax, byte clip)
Igs the is mouse hovering rect using the specified r min
Alis.Core.Graphic.ImGui.ImGui.GetItemId
static uint GetItemId()
Gets the item id
Definition: ImGui.cs:9319
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format, string formatMax, ImGuiSliderFlags flags)
Describes whether drag int range 2
Definition: ImGui.cs:7926
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igListBox_Str_arr
static byte igListBox_Str_arr(byte *label, int *currentItem, byte **items, int itemsCount, int heightInItems)
Igs the list box str arr using the specified label
Alis.Core.Graphic.ImGui.ImGui.BulletText
static void BulletText(string fmt)
Bullets the text using the specified fmt
Definition: ImGui.cs:1823
Alis.Core.Graphic.ImGui.ImGui.ShowStackToolWindow
static void ShowStackToolWindow(ref bool pOpen)
Shows the stack tool window using the specified p open
Definition: ImGui.cs:17102
Alis.Core.Graphic.ImGui.ImGui.Combo
static bool Combo(string label, ref int currentItem, string[] items, int itemsCount)
Describes whether combo
Definition: ImGui.cs:2955
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTextDisabled
static void igTextDisabled(byte *fmt)
Igs the text disabled using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.LogToFile
static void LogToFile(int autoOpenDepth, string filename)
Logs the to file using the specified auto open depth
Definition: ImGui.cs:13435
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragScalarN
static byte igDragScalarN(byte *label, ImGuiDataType dataType, void *pData, int components, float vSpeed, void *pMin, void *pMax, byte *format, ImGuiSliderFlags flags)
Igs the drag scalar n using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderInt3
static bool SliderInt3(string label, ref int v, int vMin, int vMax, string format)
Describes whether slider int 3
Definition: ImGui.cs:18894
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowFocused
static byte igIsWindowFocused(ImGuiFocusedFlags flags)
Igs the is window focused using the specified flags
Alis.Core.Graphic.ImGui.Structs.ImGuiStoragePtr
The im gui storage ptr
Definition: ImGuiStoragePtr.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDestroyContext
static void igDestroyContext(IntPtr ctx)
Igs the destroy context using the specified ctx
Alis.Core.Graphic.ImGui.ImGui.GetBackgroundDrawList
static ImDrawListPtr GetBackgroundDrawList()
Gets the background draw list
Definition: ImGui.cs:8918
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemActivated
static byte igIsItemActivated()
Igs the is item activated
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMousePosValid
static byte igIsMousePosValid(Vector2F *mousePos)
Igs the is mouse pos valid using the specified mouse pos
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableNextColumn
static byte igTableNextColumn()
Igs the table next column
Alis.Core.Graphic.ImGui.ImGui.TableNextRow
static void TableNextRow(ImGuiTableRowFlags rowFlags, float minRowHeight)
Tables the next row using the specified row flags
Definition: ImGui.cs:20001
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether drag float 4
Definition: ImGui.cs:5103
Alis.Core.Graphic.ImGui.ImGui.SetScrollHereX
static void SetScrollHereX(float centerXRatio)
Sets the scroll here x using the specified center x ratio
Definition: ImGui.cs:16501
Alis.Core.Graphic.ImGui.Enums.ImGuiColorEditFlags
ImGuiColorEditFlags
The im gui color edit flags enum
Definition: ImGuiColorEditFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextItem
static bool BeginPopupContextItem(string strId)
Describes whether begin popup context item
Definition: ImGui.cs:1032
Alis.Core.Graphic.ImGui.ImGui.IsItemHovered
static bool IsItemHovered()
Describes whether is item hovered
Definition: ImGui.cs:12617
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollHereX
static void igSetScrollHereX(float centerXRatio)
Igs the set scroll here x using the specified center x ratio
Alis.Core.Graphic.ImGui.Enums.ImGuiButtonFlags
ImGuiButtonFlags
The im gui button flags enum
Definition: ImGuiButtonFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float 2
Definition: ImGui.cs:4186
Alis.Core.Graphic.ImGui.ImGui.BeginDisabled
static void BeginDisabled(bool disabled)
Begins the disabled using the specified disabled
Definition: ImGui.cs:708
Alis.Core.Graphic.ImGui.ImGui.LabelText
static void LabelText(string label, string fmt)
Labels the text using the specified label
Definition: ImGui.cs:13018
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether drag float 3
Definition: ImGui.cs:4683
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, ref string input, uint maxLength)
Describes whether input text
Alis.Core.Graphic.ImGui.ImGui.ShowStackToolWindow
static void ShowStackToolWindow()
Shows the stack tool window
Definition: ImGui.cs:17092
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSelectable_BoolPtr
static byte igSelectable_BoolPtr(byte *label, byte *pSelected, ImGuiSelectableFlags flags, Vector2F size)
Igs the selectable bool ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.ShowStyleEditor
static void ShowStyleEditor()
Shows the style editor
Definition: ImGui.cs:17113
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFrameHeight
static float igGetFrameHeight()
Igs the get frame height
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad, float vDegreesMin)
Describes whether slider angle
Definition: ImGui.cs:17248
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextVoid
static bool BeginPopupContextVoid()
Describes whether begin popup context void
Definition: ImGui.cs:1111
Alis.Core.Graphic.ImGui.ImGui.InputFloat4
static bool InputFloat4(string label, ref Vector4F v)
Describes whether input float 4
Definition: ImGui.cs:11166
Alis.Core.Graphic.ImGui.ImGui.ShowAboutWindow
static void ShowAboutWindow()
Shows the about window
Definition: ImGui.cs:16972
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components)
Describes whether input scalar n
Definition: ImGui.cs:12119
Alis.Core.Graphic.ImGui.ImGui.Indent
static void Indent()
Indents
Definition: ImGui.cs:10029
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginMenuBar
static byte igBeginMenuBar()
Igs the begin menu bar
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLabelText
static void igLabelText(byte *label, byte *fmt)
Igs the label text using the specified label
Alis.Core.Graphic.ImGui.ImGui.InvisibleButton
static bool InvisibleButton(string strId, Vector2F size)
Describes whether invisible button
Definition: ImGui.cs:12415
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, ref bool pSelected, ImGuiSelectableFlags flags, Vector2F size)
Describes whether selectable
Definition: ImGui.cs:15868
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLoadIniSettingsFromDisk
static void igLoadIniSettingsFromDisk(byte *iniFilename)
Igs the load ini settings from disk using the specified ini filename
Alis.Core.Graphic.ImGui.ImGui.GetTextLineHeightWithSpacing
static float GetTextLineHeightWithSpacing()
Gets the text line height with spacing
Definition: ImGui.cs:9591
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginTabItem
static byte igBeginTabItem(byte *label, byte *pOpen, ImGuiTabItemFlags flags)
Igs the begin tab item using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopItemWidth
static void igPopItemWidth()
Igs the pop item width
Alis.Core.Graphic.ImGui.ImGui.BeginTabItem
static bool BeginTabItem(string label)
Describes whether begin tab item
Definition: ImGui.cs:1505
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v)
Describes whether input double
Definition: ImGui.cs:10050
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowAppearing
static byte igIsWindowAppearing()
Igs the is window appearing
Alis.Core.Graphic.ImGui.Structs.ImFontPtr
The im font ptr
Definition: ImFontPtr.cs:40
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowCollapsed
static void SetNextWindowCollapsed(bool collapsed)
Sets the next window collapsed using the specified collapsed
Definition: ImGui.cs:16285
Alis.Core.Graphic.ImGui.ImGui.GetTextLineHeight
static float GetTextLineHeight()
Gets the text line height
Definition: ImGui.cs:9581
Alis.Core.Graphic.ImGui.ImGui.Begin
static bool Begin(string name, ImGuiWindowFlags flags)
Describes whether begin
Definition: ImGui.cs:22440
Alis.Core.Graphic.ImGui.Structs.ImGuiTableSortSpecs
The im gui table sort specs
Definition: ImGuiTableSortSpecs.cs:36
Alis.Core.Graphic
Definition: Button.cs:31
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSameLine
static void igSameLine(float offsetFromStartX, float spacing)
Igs the same line using the specified offset from start x
Alis.Core.Graphic.ImGui.ImGui.InvisibleButton
static bool InvisibleButton(string strId, Vector2F size, ImGuiButtonFlags flags)
Describes whether invisible button
Definition: ImGui.cs:12457
Alis.Core.Graphic.ImGui.ImGui.TableHeadersRow
static void TableHeadersRow()
Tables the headers row
Definition: ImGui.cs:19961
Alis.Core.Graphic.ImGui.ImGui.ResetMouseDragDelta
static void ResetMouseDragDelta(ImGuiMouseButton button)
Resets the mouse drag delta using the specified button
Definition: ImGui.cs:15503
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(string strId, Vector2F size, bool border)
Describes whether begin child
Definition: ImGui.cs:394
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseDoubleClicked
static byte igIsMouseDoubleClicked(ImGuiMouseButton button)
Igs the is mouse double clicked using the specified button
Alis.Core.Graphic.ImGui.ImGui.DockSpace
static uint DockSpace(uint id, Vector2F size, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
Docks the space using the specified id
Definition: ImGui.cs:3425
Alis.Core.Graphic.ImGui.Utils.Util.AreStringsEqual
static bool AreStringsEqual(byte *a, int aLength, byte *b)
Describes whether are strings equal
Definition: Util.cs:69
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowCollapsed
static void igSetNextWindowCollapsed(byte collapsed, ImGuiCond cond)
Igs the set next window collapsed using the specified collapsed
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsAnyItemFocused
static byte igIsAnyItemFocused()
Igs the is any item focused
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputScalar
static byte igInputScalar(byte *label, ImGuiDataType dataType, void *pData, void *pStep, void *pStepFast, byte *format, ImGuiInputTextFlags flags)
Igs the input scalar using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushID_Str
static void igPushID_Str(byte *strId)
Igs the push id str using the specified str id
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax)
Describes whether slider angle
Definition: ImGui.cs:17315
Alis.Core.Graphic.ImGui.ImGui.PushId
static void PushId(string strId)
Pushes the id using the specified str id
Definition: ImGui.cs:15236
Alis.Core.Graphic.ImGui.ImGui.ShowMetricsWindow
static void ShowMetricsWindow()
Shows the metrics window
Definition: ImGui.cs:17071
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInvisibleButton
static byte igInvisibleButton(byte *strId, Vector2F size, ImGuiButtonFlags flags)
Igs the invisible button using the specified str id
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, ref bool pSelected)
Describes whether selectable
Definition: ImGui.cs:15776
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetTextLineHeight
static float igGetTextLineHeight()
Igs the get text line height
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetScrollX
static float igGetScrollX()
Igs the get scroll x
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed)
Describes whether drag scalar
Definition: ImGui.cs:8077
Alis.Core.Graphic.ImGui.ImGui.PopStyleVar
static void PopStyleVar(int count)
Pops the style var using the specified count
Definition: ImGui.cs:15119
Alis.Core.Graphic.ImGui.Structs.ImDrawData
The im draw data
Definition: ImDrawData.cs:38
Alis.Core.Graphic.ImGui.ImGui.EndDragDropTarget
static void EndDragDropTarget()
Ends the drag drop target
Definition: ImGui.cs:8778
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igValue_Uint
static void igValue_Uint(byte *prefix, uint v)
Igs the value uint using the specified prefix
Alis.Core.Graphic.ImGui.Structs
Definition: ImColor.cs:33
Alis.Core.Graphic.ImGui.ImGui.Checkbox
static bool Checkbox(string label, ref bool v)
Describes whether checkbox
Definition: ImGui.cs:1951
Alis.Core.Graphic.ImGui.ImGui.SetWindowPos
static void SetWindowPos(Vector2F pos, ImGuiCond cond)
Sets the window pos using the specified pos
Definition: ImGui.cs:16792
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogToFile
static void igLogToFile(int autoOpenDepth, byte *filename)
Igs the log to file using the specified auto open depth
Alis.Core.Graphic.ImGui.ImGui.TableNextRow
static void TableNextRow()
Tables the next row
Definition: ImGui.cs:19979
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginCombo
static byte igBeginCombo(byte *label, byte *previewValue, ImGuiComboFlags flags)
Igs the begin combo using the specified label
Alis.Core.Graphic.ImGui.ImGui.SameLine
static void SameLine(float offsetFromStartX, float spacing)
Sames the line using the specified offset from start x
Definition: ImGui.cs:15533
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDestroyPlatformWindows
static void igDestroyPlatformWindows()
Igs the destroy platform windows
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowCollapsed_Str
static void igSetWindowCollapsed_Str(byte *name, byte collapsed, ImGuiCond cond)
Igs the set window collapsed str using the specified name
Alis.Core.Graphic.ImGui.ImGui.SetAllocatorFunctions
static void SetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc)
Sets the allocator functions using the specified alloc func
Definition: ImGui.cs:15954
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed)
Describes whether drag int 2
Definition: ImGui.cs:6249
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorConvertRGBtoHSV
static void igColorConvertRGBtoHSV(float r, float g, float b, float *outH, float *outS, float *outV)
Igs the color convert rg bto hsv using the specified r
Alis.Core.Graphic.ImGui.ImGui.ShowDemoWindow
static void ShowDemoWindow()
Shows the demo window
Definition: ImGui.cs:17014
Alis.Core.Graphic.ImGui.ImGui.IsWindowDocked
static bool IsWindowDocked()
Describes whether is window docked
Definition: ImGui.cs:12963
Alis.Core.Graphic.ImGui.ImGui.PushId
static void PushId(IntPtr ptrId)
Pushes the id using the specified ptr id
Definition: ImGui.cs:15272
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputFloat2
static byte igInputFloat2(byte *label, Vector2F *v, byte *format, ImGuiInputTextFlags flags)
Igs the input float 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed)
Describes whether drag float range 2
Definition: ImGui.cs:5248
Alis.Core.Graphic.ImGui.ImGui.IsItemEdited
static bool IsItemEdited()
Describes whether is item edited
Definition: ImGui.cs:12597
Alis.Core.Graphic.ImGui.ImGui.CollapsingHeader
static bool CollapsingHeader(string label)
Describes whether collapsing header
Definition: ImGui.cs:2089
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed)
Describes whether drag float 4
Definition: ImGui.cs:4822
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputInt4
static byte igInputInt4(byte *label, int *v, ImGuiInputTextFlags flags)
Igs the input int 4 using the specified label
Alis.Core.Graphic.ImGui.Enums.ImGuiComboFlags
ImGuiComboFlags
The im gui combo flags enum
Definition: ImGuiComboFlags.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColorU32_Col
static uint igGetColorU32_Col(ImGuiCol idx, float alphaMul)
Igs the get color u 32 col using the specified idx
Alis.Core.Graphic.ImGui.ImGui.SliderFloat4
static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax, string format)
Describes whether slider float 4
Definition: ImGui.cs:18246
Alis.Core.Graphic.ImGui.ImGui.PopItemWidth
static void PopItemWidth()
Pops the item width
Definition: ImGui.cs:15083
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginMainMenuBar
static byte igBeginMainMenuBar()
Igs the begin main menu bar
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCursorScreenPos
static void igSetCursorScreenPos(Vector2F pos)
Igs the set cursor screen pos using the specified pos
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorButton
static byte igColorButton(byte *descId, Vector4F col, ImGuiColorEditFlags flags, Vector2F size)
Igs the color button using the specified desc id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginDragDropSource
static byte igBeginDragDropSource(ImGuiDragDropFlags flags)
Igs the begin drag drop source using the specified flags
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin)
Describes whether drag scalar n
Definition: ImGui.cs:8473
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputDouble
static byte igInputDouble(byte *label, double *v, double step, double stepFast, byte *format, ImGuiInputTextFlags flags)
Igs the input double using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemDeactivated
static byte igIsItemDeactivated()
Igs the is item deactivated
Alis.Core.Graphic.ImGui.ImGui.GetTreeNodeToLabelSpacing
static float GetTreeNodeToLabelSpacing()
Gets the tree node to label spacing
Definition: ImGui.cs:9611
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloat3
static byte igDragFloat3(byte *label, Vector3F *v, float vSpeed, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the drag float 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.SetScrollHereX
static void SetScrollHereX()
Sets the scroll here x
Definition: ImGui.cs:16491
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, bool b)
Values the prefix
Definition: ImGui.cs:20822
Alis.Core.Graphic.ImGui.ImGui.SetScrollHereY
static void SetScrollHereY(float centerYRatio)
Sets the scroll here y using the specified center y ratio
Definition: ImGui.cs:16519
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin)
Describes whether drag int range 2
Definition: ImGui.cs:7588
Alis.Core.Graphic.ImGui.Enums.ImGuiTreeNodeFlags
ImGuiTreeNodeFlags
The im gui tree node flags enum
Definition: ImGuiTreeNodeFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.TableSetupScrollFreeze
static void TableSetupScrollFreeze(int cols, int rows)
Tables the setup scroll freeze using the specified cols
Definition: ImGui.cs:20211
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetVersion
static byte * igGetVersion()
Igs the get version
Alis.Core.Graphic.ImGui.ImGui.SaveIniSettingsToDisk
static void SaveIniSettingsToDisk(string iniFilename)
Saves the ini settings to disk using the specified ini filename
Definition: ImGui.cs:15542
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushButtonRepeat
static void igPushButtonRepeat(byte repeat)
Igs the push button repeat using the specified repeat
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDockSpaceOverViewport
static uint igDockSpaceOverViewport(ImGuiViewport *viewport, ImGuiDockNodeFlags flags, ImGuiWindowClass *windowClass)
Igs the dock space over viewport using the specified viewport
Alis.Core.Graphic.ImGui.ImGui.IsPopupOpen
static bool IsPopupOpen(string strId)
Describes whether is popup open
Definition: ImGui.cs:12841
Alis.Core.Graphic.ImGui.ImGui.Button
static bool Button(string label)
Describes whether button
Definition: ImGui.cs:1860
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v)
Describes whether drag int 3
Definition: ImGui.cs:6601
Alis.Core.Graphic.ImGui.ImGui.GetCursorScreenPos
static Vector2F GetCursorScreenPos()
Gets the cursor screen pos
Definition: ImGui.cs:9123
Alis.Core.Graphic.ImGui.ImGui.DockSpaceOverViewport
static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr windowClass)
Docks the space over viewport using the specified viewport
Definition: ImGui.cs:3480
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloatRange2
static byte igDragFloatRange2(byte *label, float *vCurrentMin, float *vCurrentMax, float vSpeed, float vMin, float vMax, byte *format, byte *formatMax, ImGuiSliderFlags flags)
Igs the drag float range 2 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCheckbox
static byte igCheckbox(byte *label, byte *v)
Igs the checkbox using the specified label
Alis.Core.Graphic.ImGui.ImGui.VSliderScalar
static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
Describes whether v slider scalar
Definition: ImGui.cs:21609
Alis.Core.Graphic.ImGui.ImGui.BeginTable
static bool BeginTable(string strId, int column)
Describes whether begin table
Definition: ImGui.cs:1635
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopTabStop
static void igPopTabStop()
Igs the pop tab stop
Alis.Core.Graphic.ImGui.ImGui.SliderFloat4
static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax)
Describes whether slider float 4
Definition: ImGui.cs:18179
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax, string format)
Describes whether drag scalar
Definition: ImGui.cs:8224
Alis.Core.Graphic.ImGui.ImGui.OpenPopup
static void OpenPopup(uint id, ImGuiPopupFlags popupFlags)
Opens the popup using the specified id
Definition: ImGui.cs:14021
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCheckboxFlags_UintPtr
static byte igCheckboxFlags_UintPtr(byte *label, uint *flags, uint flagsValue)
Igs the checkbox flags uint ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderFloat
static bool SliderFloat(string label, ref float v, float vMin, float vMax)
Describes whether slider float
Definition: ImGui.cs:17531
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetColumnFlags
static ImGuiTableColumnFlags igTableGetColumnFlags(int columnN)
Igs the table get column flags using the specified column n
Alis.Core.Graphic.ImGui.ImGui.Dummy
static void Dummy(Vector2F size)
Dummies the size
Definition: ImGui.cs:8722
Alis.Core.Graphic.ImGui.ImGui.GetScrollMaxX
static float GetScrollMaxX()
Gets the scroll max x
Definition: ImGui.cs:9499
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFrameHeightWithSpacing
static float igGetFrameHeightWithSpacing()
Igs the get frame height with spacing
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputInt2
static byte igInputInt2(byte *label, int *v, ImGuiInputTextFlags flags)
Igs the input int 2 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiWindowClassPtr
The im gui window class ptr
Definition: ImGuiWindowClassPtr.cs:40
Alis.Core.Graphic.ImGui.ImGui.LogToFile
static void LogToFile(int autoOpenDepth)
Logs the to file using the specified auto open depth
Definition: ImGui.cs:13424
Alis.Core.Graphic.ImGui.ImGui.InputFloat2
static bool InputFloat2(string label, ref Vector2F v)
Describes whether input float 2
Definition: ImGui.cs:10746
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragInt3
static byte igDragInt3(byte *label, int *v, float vSpeed, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the drag int 3 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetupColumn
static void igTableSetupColumn(byte *label, ImGuiTableColumnFlags flags, float initWidthOrWeight, uint userId)
Igs the table setup column using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetSortSpecs
static ImGuiTableSortSpecs * igTableGetSortSpecs()
Igs the table get sort specs
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetDragDropPayload
static byte igSetDragDropPayload(byte *type, void *data, uint sz, ImGuiCond cond)
Igs the set drag drop payload using the specified type
Alis.Core.Graphic.ImGui.ImGui.IsMouseReleased
static bool IsMouseReleased(ImGuiMouseButton button)
Describes whether is mouse released
Definition: ImGui.cs:12830
Alis.Core.Graphic.ImGui.ImGui.LogText
static void LogText(string fmt)
Logs the text using the specified fmt
Definition: ImGui.cs:13360
Alis.Core.Graphic.ImGui.ImGui.SliderScalarN
static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax)
Describes whether slider scalar n
Definition: ImGui.cs:19461
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igNewLine
static void igNewLine()
Igs the new line
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetItemID
static uint igGetItemID()
Igs the get item id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMousePosOnOpeningCurrentPopup
static void igGetMousePosOnOpeningCurrentPopup(Vector2F *pOut)
Igs the get mouse pos on opening current popup using the specified p out
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, float v, string floatFormat)
Values the prefix
Definition: ImGui.cs:20973
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushStyleColor_Vec4
static void igPushStyleColor_Vec4(ImGuiCol idx, Vector4F col)
Igs the push style color vec 4 using the specified idx
Alis.Core.Graphic.ImGui.ImGui.IsWindowFocused
static bool IsWindowFocused()
Describes whether is window focused
Definition: ImGui.cs:12973
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorEdit4
static byte igColorEdit4(byte *label, Vector4F *col, ImGuiColorEditFlags flags)
Igs the color edit 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.StyleColorsLight
static void StyleColorsLight()
Styles the colors light
Definition: ImGui.cs:19742
Alis.Core.Graphic.ImGui.ImGui.GetStyleColorVec4
static Vector4F * GetStyleColorVec4(ImGuiCol idx)
Gets the style color vec 4 using the specified idx
Definition: ImGui.cs:9571
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputInt3
static byte igInputInt3(byte *label, int *v, ImGuiInputTextFlags flags)
Igs the input int 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderScalar
static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format)
Describes whether slider scalar
Definition: ImGui.cs:19309
Alis.Core.Graphic.ImGui.ImGui.PushStyleVar
static void PushStyleVar(ImGuiStyleVar idx, Vector2F val)
Pushes the style var using the specified idx
Definition: ImGui.cs:15331
Alis.Core.Graphic.ImGui.Enums.ImGuiCond
ImGuiCond
The im gui cond enum
Definition: ImGuiCond.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowSize
static void igGetWindowSize(Vector2F *pOut)
Igs the get window size using the specified p out
Alis.Core.Graphic.ImGui.ImGui.LogFinish
static void LogFinish()
Logs the finish
Definition: ImGui.cs:13351
Alis.Core.Graphic.ImGui.ImGui.EndCombo
static void EndCombo()
Ends the combo
Definition: ImGui.cs:8754
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowPos
static void SetNextWindowPos(Vector2F pos)
Sets the next window pos using the specified pos
Definition: ImGui.cs:16344
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollX_Float
static void igSetScrollX_Float(float scrollX)
Igs the set scroll x float using the specified scroll x
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut)
Describes whether menu item
Definition: ImGui.cs:13554
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags, Vector2F size)
Describes whether selectable
Definition: ImGui.cs:15735
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginMenu
static byte igBeginMenu(byte *label, byte enabled)
Igs the begin menu using the specified label
Alis.Core.Graphic.ImGui.ImGui.BeginCombo
static bool BeginCombo(string label, string previewValue, ImGuiComboFlags flags)
Describes whether begin combo
Definition: ImGui.cs:633
Alis.Core.Graphic.ImGui.ImGui.GetTime
static double GetTime()
Gets the time
Definition: ImGui.cs:9601
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopupContextVoid
static byte igBeginPopupContextVoid(byte *strId, ImGuiPopupFlags popupFlags)
Igs the begin popup context void using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPlotHistogram_FloatPtr
static void igPlotHistogram_FloatPtr(byte *label, float *values, int valuesCount, int valuesOffset, byte *overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
Igs the plot histogram float ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, bool hideTextAfterDoubleHash)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndTable
static void igEndTable()
Igs the end table
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetDragDropPayload
static ImGuiPayload * igGetDragDropPayload()
Igs the get drag drop payload
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloat4
static byte igDragFloat4(byte *label, Vector4F *v, float vSpeed, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the drag float 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float 4
Definition: ImGui.cs:5026
Alis.Core.Graphic.ImGui.ImGui.IsItemHovered
static bool IsItemHovered(ImGuiHoveredFlags flags)
Describes whether is item hovered
Definition: ImGui.cs:12629
Alis.Core.Graphic.ImGui.ImGui.TableGetSortSpecs
static ImGuiTableSortSpecsPtr TableGetSortSpecs()
Tables the get sort specs
Definition: ImGui.cs:19916
Alis.Core.Graphic.ImGui.ImGui.ColorButton
static bool ColorButton(string descId, Vector4F col, ImGuiColorEditFlags flags, Vector2F size)
Describes whether color button
Definition: ImGui.cs:2344
Alis.Core.Graphic.ImGui.Utils.Unsafe.CopyBlock
static unsafe void CopyBlock(void *destination, void *source, uint byteCount)
Copies bytes from the source address to the destination address.
Definition: Unsafe.cs:72
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowFocus
static void igSetNextWindowFocus()
Igs the set next window focus
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextWindow
static bool BeginPopupContextWindow()
Describes whether begin popup context window
Definition: ImGui.cs:1203
Alis.Core.Graphic.ImGui.Utils.Util.CalcSizeInUtf8
static int CalcSizeInUtf8(string s, int start, int length)
Calcs the size in utf 8 using the specified s
Definition: Util.cs:108
Alis.Core.Graphic.ImGui.ImGui.OpenPopup
static void OpenPopup(string strId, ImGuiPopupFlags popupFlags)
Opens the popup using the specified str id
Definition: ImGui.cs:13974
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreePush_Ptr
static void igTreePush_Ptr(void *ptrId)
Igs the tree push ptr using the specified ptr id
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin)
Plots the lines using the specified label
Definition: ImGui.cs:14757
Alis.Core.Graphic.ImGui.ImGui.GetForegroundDrawList
static ImDrawListPtr GetForegroundDrawList()
Gets the foreground draw list
Definition: ImGui.cs:9206
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColumnsCount
static int igGetColumnsCount()
Igs the get columns count
Alis.Core.Graphic.ImGui.ImGui.EndTable
static void EndTable()
Ends the table
Definition: ImGui.cs:8858
Alis.Core.Graphic.ImGui.ImGui.SetScrollX
static void SetScrollX(float scrollX)
Sets the scroll x using the specified scroll x
Definition: ImGui.cs:16528
Alis.Core.Graphic.ImGui.ImGui.SameLine
static void SameLine(float offsetFromStartX)
Sames the line using the specified offset from start x
Definition: ImGui.cs:15522
Alis.Core.Graphic.ImGui.ImGui.EndMainMenuBar
static void EndMainMenuBar()
Ends the main menu bar
Definition: ImGui.cs:8810
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCurrentContext
static void igSetCurrentContext(IntPtr ctx)
Igs the set current context using the specified ctx
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowHeight
static float igGetWindowHeight()
Igs the get window height
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetKeyboardFocusHere
static void igSetKeyboardFocusHere(int offset)
Igs the set keyboard focus here using the specified offset
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderScalar
static byte igSliderScalar(byte *label, ImGuiDataType dataType, void *pData, void *pMin, void *pMax, byte *format, ImGuiSliderFlags flags)
Igs the slider scalar using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetUtf8Bytes
static byte * GetUtf8Bytes(string text)
Gets the utf 8 bytes using the specified text
Definition: ImGui.cs:22101
Alis.Core.Aspect.Math.Vector.Vector2F.Length
readonly float Length()
Returns the length of the vector.
Definition: Vector2F.cs:490
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, byte[] buf, uint bufSize, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
Describes whether input text
Alis.Core.Graphic.ImGui.Enums.ImGuiFocusedFlags
ImGuiFocusedFlags
The im gui focused flags enum
Definition: ImGuiFocusedFlags.cs:39
Alis.Core.Graphic.ImGui.ImGui.TreeNodeEx
static bool TreeNodeEx(string strId, ImGuiTreeNodeFlags flags, string fmt)
Describes whether tree node ex
Definition: ImGui.cs:20633
Alis.Core.Graphic.ImGui.ImGui.GetId
static uint GetId(IntPtr ptrId)
Gets the id using the specified ptr id
Definition: ImGui.cs:9298
Alis.Core.Graphic.ImGui.ImGui.LoadIniSettingsFromDisk
static void LoadIniSettingsFromDisk(string iniFilename)
Loads the ini settings from disk using the specified ini filename
Definition: ImGui.cs:13234
Alis.Core.Graphic.ImGui.ImGui.SliderScalar
static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax)
Describes whether slider scalar
Definition: ImGui.cs:19260
Alis.Core.Graphic.ImGui.ImGui.CheckboxFlags
static bool CheckboxFlags(string label, ref uint flags, uint flagsValue)
Describes whether checkbox flags
Definition: ImGui.cs:2039
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushTabStop
static void igPushTabStop(byte tabStop)
Igs the push tab stop using the specified tab stop
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndMainMenuBar
static void igEndMainMenuBar()
Igs the end main menu bar
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushStyleColor_U32
static void igPushStyleColor_U32(ImGuiCol idx, uint col)
Igs the push style color u 32 using the specified idx
Alis.Core.Graphic.ImGui.ImGui.TextDisabled
static void TextDisabled(string fmt)
Texts the disabled using the specified fmt
Definition: ImGui.cs:20293
Alis.Core.Graphic.ImGui.ImGui.ColorEdit3
static bool ColorEdit3(string label, ref Vector3F col)
Describes whether color edit 3
Definition: ImGui.cs:2452
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether drag int
Definition: ImGui.cs:6110
Alis.Core.Graphic.ImGui.ImGui.InputFloat2
static bool InputFloat2(string label, ref Vector2F v, string format, ImGuiInputTextFlags flags)
Describes whether input float 2
Definition: ImGui.cs:10885
Alis.Core.Graphic.ImGui.ImGui.GetDrawData
static ImDrawDataPtr GetDrawData()
Gets the draw data
Definition: ImGui.cs:9155
Alis.Core.Graphic.ImGui.ImGui.SaveIniSettingsToMemory
static string SaveIniSettingsToMemory(out uint outIniSize)
Saves the ini settings to memory using the specified out ini size
Definition: ImGui.cs:15590
Alis.Core.Graphic.ImGui.ImGui.GetKeyIndex
static ImGuiKey GetKeyIndex(ImGuiKey key)
Gets the key index using the specified key
Definition: ImGui.cs:9363
Alis.Core.Graphic.ImGui.ImGui.TreeNode
static bool TreeNode(string strId, string fmt)
Describes whether tree node
Definition: ImGui.cs:20443
Alis.Core.Graphic.ImGui.ImGui.CollapsingHeader
static bool CollapsingHeader(string label, ref bool pVisible)
Describes whether collapsing header
Definition: ImGui.cs:2170
Alis.Core.Graphic.ImGui.ImGui.DockSpace
static uint DockSpace(uint id, Vector2F size, ImGuiDockNodeFlags flags)
Docks the space using the specified id
Definition: ImGui.cs:3410
Alis.Core.Graphic.ImGui.ImGui.ColorPicker4
static bool ColorPicker4(string label, ref Vector4F col)
Describes whether color picker 4
Definition: ImGui.cs:2716
Alis.Core.Graphic.ImGui.ImGui.ShowFontSelector
static void ShowFontSelector(string label)
Shows the font selector using the specified label
Definition: ImGui.cs:17036
Alis.Core.Graphic.ImGui.ImGui.IsItemClicked
static bool IsItemClicked()
Describes whether is item clicked
Definition: ImGui.cs:12555
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label)
Describes whether menu item
Definition: ImGui.cs:13511
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowDocked
static byte igIsWindowDocked()
Igs the is window docked
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igStyleColorsClassic
static void igStyleColorsClassic(ImGuiStyle *dst)
Igs the style colors classic using the specified dst
Alis.Core.Graphic.ImGui.ImGui.GetScrollY
static float GetScrollY()
Gets the scroll y
Definition: ImGui.cs:9529
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDockSpace
static uint igDockSpace(uint id, Vector2F size, ImGuiDockNodeFlags flags, ImGuiWindowClass *windowClass)
Igs the dock space using the specified id
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size)
Images the user texture id
Definition: ImGui.cs:9736
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowStackToolWindow
static void igShowStackToolWindow(byte *pOpen)
Igs the show stack tool window using the specified p open
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginTooltip
static byte igBeginTooltip()
Igs the begin tooltip
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextItemOpen
static void igSetNextItemOpen(byte isOpen, ImGuiCond cond)
Igs the set next item open using the specified is open
Alis.Core.Graphic.ImGui.ImGui.AreUtf8StringsEqual
static bool AreUtf8StringsEqual(byte *utf8Bytes, string text)
Describes whether are utf 8 strings equal
Definition: ImGui.cs:22142
Alis.Core.Graphic.ImGui.ImGui.SetWindowCollapsed
static void SetWindowCollapsed(bool collapsed, ImGuiCond cond)
Sets the window collapsed using the specified collapsed
Definition: ImGui.cs:16640
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float range 2
Definition: ImGui.cs:5467
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemVisible
static byte igIsItemVisible()
Igs the is item visible
Alis.Core.Graphic.ImGui.ImGui.StyleColorsDark
static void StyleColorsDark()
Styles the colors dark
Definition: ImGui.cs:19723
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igFindViewportByID
static ImGuiViewport * igFindViewportByID(uint id)
Igs the find viewport by id using the specified id
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextVoid
static bool BeginPopupContextVoid(string strId, ImGuiPopupFlags popupFlags)
Describes whether begin popup context void
Definition: ImGui.cs:1165
Alis.Core.Graphic.ImGui.ImGui.ShowStyleEditor
static void ShowStyleEditor(ImGuiStylePtr @ref)
Definition: ImGui.cs:17122
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowSize_Vec2
static void igSetWindowSize_Vec2(Vector2F size, ImGuiCond cond)
Igs the set window size vec 2 using the specified size
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether drag int 3
Definition: ImGui.cs:6950
Alis.Core.Graphic.ImGui.ImGui.SetKeyboardFocusHere
static void SetKeyboardFocusHere(int offset)
Sets the keyboard focus here using the specified offset
Definition: ImGui.cs:16197
Alis.Core.Graphic.ImGui.ImGui.Columns
static void Columns(int count, string id)
Columnses the count
Definition: ImGui.cs:2875
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowUserGuide
static void igShowUserGuide()
Igs the show user guide
Alis.Core.Graphic.ImGui.Structs.ImFontAtlas
The im font atlas
Definition: ImFontAtlas.cs:40
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputScalarN
static byte igInputScalarN(byte *label, ImGuiDataType dataType, void *pData, int components, void *pStep, void *pStepFast, byte *format, ImGuiInputTextFlags flags)
Igs the input scalar n using the specified label
Alis.Core.Graphic.ImGui.ImGui.InputTextMultiline
static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2F size, ImGuiInputTextFlags flags)
Describes whether input text multiline
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowWidth
static float igGetWindowWidth()
Igs the get window width
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount)
Plots the histogram using the specified label
Definition: ImGui.cs:14116
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCreateContext
static IntPtr igCreateContext(ImFontAtlas *sharedFontAtlas)
Igs the create context using the specified shared font atlas
Alis.Core.Graphic.ImGui.ImGui.SliderFloat3
static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax)
Describes whether slider float 3
Definition: ImGui.cs:17963
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.ImGui.SetItemAllowOverlap
static void SetItemAllowOverlap()
Sets the item allow overlap
Definition: ImGui.cs:16171
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igUpdatePlatformWindows
static void igUpdatePlatformWindows()
Igs the update platform windows
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowDemoWindow
static void igShowDemoWindow(byte *pOpen)
Igs the show demo window using the specified p open
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label)
Describes whether selectable
Definition: ImGui.cs:15604
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igMenuItem_Bool
static byte igMenuItem_Bool(byte *label, byte *shortcut, byte selected, byte enabled)
Igs the menu item bool using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiStorage
The im gui storage
Definition: ImGuiStorage.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFont
static ImFont * igGetFont()
Igs the get font
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsPopupOpen_Str
static byte igIsPopupOpen_Str(byte *strId, ImGuiPopupFlags flags)
Igs the is popup open str using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsAnyMouseDown
static byte igIsAnyMouseDown()
Igs the is any mouse down
Alis.Core.Graphic.ImGui.Structs.ImGuiWindowClassPtr.NativePtr
ImGuiWindowClass * NativePtr
Gets the value of the native ptr
Definition: ImGuiWindowClassPtr.cs:44
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igText
static void igText(byte *fmt)
Igs the text using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.GetUtf8BytesLength
static int GetUtf8BytesLength(byte *utf8Bytes)
Gets the utf 8 bytes length using the specified utf 8 bytes
Definition: ImGui.cs:22173
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEnd
static void igEnd()
Igs the end
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast, string format, ImGuiInputTextFlags flags)
Describes whether input scalar
Definition: ImGui.cs:12046
Alis.Core.Graphic.ImGui.ImGui.GetPlatformIo
static ImGuiPlatformIoPtr GetPlatformIo()
Gets the platform io
Definition: ImGui.cs:9489
Alis.Core.Graphic.ImGui.ImGui.ColorPicker3
static bool ColorPicker3(string label, ref Vector3F col)
Describes whether color picker 3
Definition: ImGui.cs:2628
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol, Vector4F tintCol)
Describes whether image button
Definition: ImGui.cs:9992
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMouseDragDelta
static void igGetMouseDragDelta(Vector2F *pOut, ImGuiMouseButton button, float lockThreshold)
Igs the get mouse drag delta using the specified p out
Alis.Core.Graphic.ImGui.ImGui.PushTabStop
static void PushTabStop(bool tabStop)
Pushes the tab stop using the specified tab stop
Definition: ImGui.cs:15340
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut, ref bool pSelected)
Describes whether menu item
Definition: ImGui.cs:13768
Alis.Core.Graphic.ImGui.ImGui.EndDisabled
static void EndDisabled()
Ends the disabled
Definition: ImGui.cs:8762
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowPos_Vec2
static void igSetWindowPos_Vec2(Vector2F pos, ImGuiCond cond)
Igs the set window pos vec 2 using the specified pos
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
Plots the histogram using the specified label
Definition: ImGui.cs:14516
Alis.Core.Graphic.ImGui.ImGui.SmallButton
static bool SmallButton(string label)
Describes whether small button
Definition: ImGui.cs:19659
Alis.Core.Graphic.ImGui.ImGui.GetStateStorage
static ImGuiStoragePtr GetStateStorage()
Gets the state storage
Definition: ImGui.cs:9539
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColorU32_U32
static uint igGetColorU32_U32(uint col)
Igs the get color u 32 u 32 using the specified col
Alis.Core.Graphic.ImGui.ImGui.SliderInt3
static bool SliderInt3(string label, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether slider int 3
Definition: ImGui.cs:18970
Alis.Core.Graphic.ImGui.ImGui.SetColumnOffset
static void SetColumnOffset(int columnIndex, float offsetX)
Sets the column offset using the specified column index
Definition: ImGui.cs:16022
Alis.Core.Graphic.ImGui.ImGui.BeginPopupModal
static bool BeginPopupModal(string name, ref bool pOpen)
Describes whether begin popup modal
Definition: ImGui.cs:1338
Alis.Core.Graphic.ImGui.ImGui.TableHeader
static void TableHeader(string label)
Tables the header using the specified label
Definition: ImGui.cs:19926
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollY_Float
static void igSetScrollY_Float(float scrollY)
Igs the set scroll y float using the specified scroll y
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndMenu
static void igEndMenu()
Igs the end menu
Alis.Core.Graphic.ImGui.ImGui.SetNextItemOpen
static void SetNextItemOpen(bool isOpen)
Sets the next item open using the specified is open
Definition: ImGui.cs:16235
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetKeyIndex
static ImGuiKey igGetKeyIndex(ImGuiKey key)
Igs the get key index using the specified key
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnFlags
static ImGuiTableColumnFlags TableGetColumnFlags()
Tables the get column flags
Definition: ImGui.cs:19852
Alis.Core.Graphic.ImGui.ImGui.GetColumnIndex
static int GetColumnIndex()
Gets the column index
Definition: ImGui.cs:8996
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowFocus_Nil
static void igSetWindowFocus_Nil()
Igs the set window focus nil
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset)
Plots the histogram using the specified label
Definition: ImGui.cs:14164
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMouseCursor
static ImGuiMouseCursor igGetMouseCursor()
Igs the get mouse cursor
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol, Vector4F borderCol)
Images the user texture id
Definition: ImGui.cs:9796
Alis.Core.Graphic.ImGui.ImGui.GetVersion
static string GetVersion()
Gets the version
Definition: ImGui.cs:9621
Alis.Core.Graphic.ImGui.ImGui.RenderPlatformWindowsDefault
static void RenderPlatformWindowsDefault(IntPtr platformRenderArg)
Renders the platform windows default using the specified platform render arg
Definition: ImGui.cs:15471
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int 2
Definition: ImGui.cs:6453
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetContentRegionAvail
static void igGetContentRegionAvail(Vector2F *pOut)
Igs the get content region avail using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndChildFrame
static void igEndChildFrame()
Igs the end child frame
Alis.Core.Graphic.ImGui.ImGui.OpenPopup
static void OpenPopup(string strId)
Opens the popup using the specified str id
Definition: ImGui.cs:13936
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetTooltip
static void igSetTooltip(byte *fmt)
Igs the set tooltip using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int 3
Definition: ImGui.cs:6873
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderFloat
static byte igSliderFloat(byte *label, float *v, float vMin, float vMax, byte *format, ImGuiSliderFlags flags)
Igs the slider float using the specified label
Alis.Core.Graphic.ImGui.ImGui.SetClipboardText
static void SetClipboardText(string text)
Sets the clipboard text using the specified text
Definition: ImGui.cs:15976
Alis.Core.Graphic.ImGui.ImGui.IsItemDeactivatedAfterEdit
static bool IsItemDeactivatedAfterEdit()
Describes whether is item deactivated after edit
Definition: ImGui.cs:12587
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCloseCurrentPopup
static void igCloseCurrentPopup()
Igs the close current popup
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax, string format, ImGuiSliderFlags flags)
Describes whether drag scalar n
Definition: ImGui.cs:8653
Alis.Core.Graphic.ImGui.ImGui.LogToClipboard
static void LogToClipboard(int autoOpenDepth)
Logs the to clipboard using the specified auto open depth
Definition: ImGui.cs:13405
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextItem
static bool BeginPopupContextItem(string strId, ImGuiPopupFlags popupFlags)
Describes whether begin popup context item
Definition: ImGui.cs:1073
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNode_Str
static byte igTreeNode_Str(byte *label)
Igs the tree node str using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether drag int 2
Definition: ImGui.cs:6530
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSmallButton
static byte igSmallButton(byte *label)
Igs the small button using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax)
Describes whether drag int 2
Definition: ImGui.cs:6385
Alis.Core.Graphic.ImGui.ImGui.EndTabBar
static void EndTabBar()
Ends the tab bar
Definition: ImGui.cs:8842
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed, int vMin)
Describes whether drag int 3
Definition: ImGui.cs:6737
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCalcItemWidth
static float igCalcItemWidth()
Igs the calc item width
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad)
Describes whether slider angle
Definition: ImGui.cs:17181
Alis.Core.Graphic.ImGui.Enums.ImGuiInputTextFlags
ImGuiInputTextFlags
The im gui input text flags enum
Definition: ImGuiInputTextFlags.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragInt
static byte igDragInt(byte *label, int *v, float vSpeed, int vMin, int vMax, byte *format, ImGuiSliderFlags flags)
Igs the drag int using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetupScrollFreeze
static void igTableSetupScrollFreeze(int cols, int rows)
Igs the table setup scroll freeze using the specified cols
Alis.Core.Graphic.ImGui.ImGui.InputFloat3
static bool InputFloat3(string label, ref Vector3F v)
Describes whether input float 3
Definition: ImGui.cs:10956
Alis.Core.Graphic.ImGui.Structs.ImDrawList
The im draw list
Definition: ImDrawList.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColumnWidth
static float igGetColumnWidth(int columnIndex)
Igs the get column width using the specified column index
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTextFlags flags)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBegin
static byte igBegin(byte *name, byte *pOpen, ImGuiWindowFlags flags)
Igs the begin using the specified name
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed)
Describes whether drag float
Definition: ImGui.cs:3562
Alis.Core.Graphic.ImGui.ImGui.GetMouseDragDelta
static Vector2F GetMouseDragDelta(ImGuiMouseButton button, float lockThreshold)
Gets the mouse drag delta using the specified button
Definition: ImGui.cs:9456
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax)
Describes whether drag float range 2
Definition: ImGui.cs:5175
Alis.Core.Graphic.ImGui.ImGui.IsRectVisible
static bool IsRectVisible(Vector2F size)
Describes whether is rect visible
Definition: ImGui.cs:12921
Alis.Core.Graphic.ImGui.ImGui.VSliderInt
static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax, string format)
Describes whether v slider int
Definition: ImGui.cs:21329
Alis.Core.Graphic.ImGui.ImGui.PopTabStop
static void PopTabStop()
Pops the tab stop
Definition: ImGui.cs:15127
Alis.Core.Graphic.ImGui.ImGui.IsMouseHoveringRect
static bool IsMouseHoveringRect(Vector2F rMin, Vector2F rMax)
Describes whether is mouse hovering rect
Definition: ImGui.cs:12779
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, ref bool pSelected, ImGuiSelectableFlags flags)
Describes whether selectable
Definition: ImGui.cs:15822
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTextColored
static void igTextColored(Vector4F col, byte *fmt)
Igs the text colored using the specified col
Alis.Core.Graphic.ImGui.ImGui.ResetMouseDragDelta
static void ResetMouseDragDelta()
Resets the mouse drag delta
Definition: ImGui.cs:15493
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableHeader
static void igTableHeader(byte *label)
Igs the table header using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMousePos
static void igGetMousePos(Vector2F *pOut)
Igs the get mouse pos using the specified p out
Alis.Core.Graphic.ImGui.Enums.ImGuiStyleVar
ImGuiStyleVar
The im gui style var enum
Definition: ImGuiStyleVar.cs:36
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr userData)
Determines whether the input text.
Definition: ImGui.cs:21817
Alis.Core.Graphic.ImGui.ImGui.LogToTty
static void LogToTty(int autoOpenDepth)
Logs the to tty using the specified auto open depth
Definition: ImGui.cs:13480
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputText
static byte igInputText(byte *label, byte *buf, uint bufSize, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void *userData)
Igs the input text using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igProgressBar
static void igProgressBar(float fraction, Vector2F sizeArg, byte *overlay)
Igs the progress bar using the specified fraction
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igButton
static byte igButton(byte *label, Vector2F size)
Igs the button using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderScalarN
static byte igSliderScalarN(byte *label, ImGuiDataType dataType, void *pData, int components, void *pMin, void *pMax, byte *format, ImGuiSliderFlags flags)
Igs the slider scalar n using the specified label
Alis.Core.Graphic.ImGui.ImGui.LogToFile
static void LogToFile()
Logs the to file
Definition: ImGui.cs:13413
Alis.Core.Graphic.ImGui.ImGui.SliderInt
static bool SliderInt(string label, ref int v, int vMin, int vMax, string format, ImGuiSliderFlags flags)
Describes whether slider int
Definition: ImGui.cs:18538
Alis.Core.Graphic.ImGui.ImGui.TextColored
static void TextColored(Vector4F col, string fmt)
Texts the colored using the specified col
Definition: ImGui.cs:20257
Alis.Core.Graphic.ImGui.ImGui.IsMouseClicked
static bool IsMouseClicked(ImGuiMouseButton button, bool repeat)
Describes whether is mouse clicked
Definition: ImGui.cs:12720
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorStartPos
static void igGetCursorStartPos(Vector2F *pOut)
Igs the get cursor start pos using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igUnindent
static void igUnindent(float indentW)
Igs the unindent using the specified indent w
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax)
Describes whether drag scalar n
Definition: ImGui.cs:8523
Alis.Core.Graphic.ImGui.ImGui.SliderFloat
static bool SliderFloat(string label, ref float v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether slider float
Definition: ImGui.cs:17674
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowCollapsed
static byte igIsWindowCollapsed()
Igs the is window collapsed
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndTabItem
static void igEndTabItem()
Igs the end tab item
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemToggledOpen
static byte igIsItemToggledOpen()
Igs the is item toggled open
Alis.Core.Graphic.ImGui.ImGui.DockSpace
static uint DockSpace(uint id)
Docks the space using the specified id
Definition: ImGui.cs:3380
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseDragging
static byte igIsMouseDragging(ImGuiMouseButton button, float lockThreshold)
Igs the is mouse dragging using the specified button
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetPlatformIO
static ImGuiPlatformIo * igGetPlatformIO()
Igs the get platform io
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowFocus
static void SetNextWindowFocus()
Sets the next window focus
Definition: ImGui.cs:16335
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextItem
static bool BeginPopupContextItem()
Describes whether begin popup context item
Definition: ImGui.cs:1019
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v, float step, float stepFast)
Describes whether input float
Definition: ImGui.cs:10532
Alis.Core.Graphic.ImGui.ImGui.LoadIniSettingsFromMemory
static void LoadIniSettingsFromMemory(string iniData, uint iniSize)
Loads the ini settings from memory using the specified ini data
Definition: ImGui.cs:13308
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax)
Describes whether drag int range 2
Definition: ImGui.cs:7442
Alis.Core.Graphic.ImGui.ImGui.DockSpace
static uint DockSpace(uint id, Vector2F size)
Docks the space using the specified id
Definition: ImGui.cs:3395
Alis.Core.Graphic.ImGui.ImGui.BeginChildFrame
static bool BeginChildFrame(uint id, Vector2F size)
Describes whether begin child frame
Definition: ImGui.cs:537
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNodeEx_Ptr
static byte igTreeNodeEx_Ptr(void *ptrId, ImGuiTreeNodeFlags flags, byte *fmt)
Igs the tree node ex ptr using the specified ptr id
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, IntPtr buf, uint bufSize)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowMetricsWindow
static void igShowMetricsWindow(byte *pOpen)
Igs the show metrics window using the specified p open
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetScrollMaxY
static float igGetScrollMaxY()
Igs the get scroll max y
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowCollapsed
static void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
Sets the next window collapsed using the specified collapsed
Definition: ImGui.cs:16297
Alis.Core.Graphic.ImGui.ImGui.GetMousePos
static Vector2F GetMousePos()
Gets the mouse pos
Definition: ImGui.cs:9467
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax)
Describes whether drag scalar
Definition: ImGui.cs:8174
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorScreenPos
static void igGetCursorScreenPos(Vector2F *pOut)
Igs the get cursor screen pos using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowSize
static void igSetNextWindowSize(Vector2F size, ImGuiCond cond)
Igs the set next window size using the specified size
Alis.Core.Graphic.ImGui.ImGui.SetScrollFromPosX
static void SetScrollFromPosX(float localX, float centerXRatio)
Sets the scroll from pos x using the specified local x
Definition: ImGui.cs:16463
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnCount
static int TableGetColumnCount()
Tables the get column count
Definition: ImGui.cs:19842
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowViewport
static void igSetNextWindowViewport(uint viewportId)
Igs the set next window viewport using the specified viewport id
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax)
Describes whether drag float range 2
Definition: ImGui.cs:5394
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igRadioButton_IntPtr
static byte igRadioButton_IntPtr(byte *label, int *v, int vButton)
Igs the radio button int ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
Describes whether input text
Alis.Core.Graphic.ImGui.ImGui.ColorButton
static bool ColorButton(string descId, Vector4F col, ImGuiColorEditFlags flags)
Describes whether color button
Definition: ImGui.cs:2301
Alis.Core.Graphic.ImGui.ImGui.CalcTextSizeImpl
static Vector2F CalcTextSizeImpl(string text, int start=0, int? length=null, bool hideTextAfterDoubleHash=false, float wrapWidth=-1.0f)
Calcs the text size impl using the specified text
Definition: ImGui.cs:22308
Alis.Core.Graphic.ImGui.ImGui.SetAllocatorFunctions
static void SetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc, IntPtr userData)
Sets the allocator functions using the specified alloc func
Definition: ImGui.cs:15966
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(string strId, Vector2F size)
Describes whether begin child
Definition: ImGui.cs:351
Alis.Core.Graphic.ImGui.ImGui.ColorPicker3
static bool ColorPicker3(string label, ref Vector3F col, ImGuiColorEditFlags flags)
Describes whether color picker 3
Definition: ImGui.cs:2673
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast, string format)
Describes whether input scalar
Definition: ImGui.cs:11969
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v)
Describes whether input float
Definition: ImGui.cs:10398
Alis.Core.Graphic.ImGui.ImGui.Indent
static void Indent(float indentW)
Indents the indent w
Definition: ImGui.cs:10039
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemFocused
static byte igIsItemFocused()
Igs the is item focused
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData)
Describes whether input scalar
Definition: ImGui.cs:11825
Alis.Core.Graphic.ImGui.ImGui.IsKeyPressed
static bool IsKeyPressed(ImGuiKey key)
Describes whether is key pressed
Definition: ImGui.cs:12671
Alis.Core.Graphic.ImGui.ImGui.PopStyleColor
static void PopStyleColor()
Pops the style color
Definition: ImGui.cs:15091
Alis.Core.Graphic.ImGui.ImGui.NextColumn
static void NextColumn()
Nexts the column
Definition: ImGui.cs:13927
Alis.Core.Graphic.ImGui.ImGui.IsItemClicked
static bool IsItemClicked(ImGuiMouseButton mouseButton)
Describes whether is item clicked
Definition: ImGui.cs:12567
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(string strId)
Describes whether begin child
Definition: ImGui.cs:308
Alis.Core.Graphic.ImGui.ImGui.ColorButton
static bool ColorButton(string descId, Vector4F col)
Describes whether color button
Definition: ImGui.cs:2258
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFontTexUvWhitePixel
static void igGetFontTexUvWhitePixel(Vector2F *pOut)
Igs the get font tex uv white pixel using the specified p out
Alis.Core.Graphic.ImGui.ImGui.PushStyleColor
static void PushStyleColor(ImGuiCol idx, Vector4F col)
Pushes the style color using the specified idx
Definition: ImGui.cs:15311
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSizeConstraints
static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback, IntPtr customCallbackData)
Sets the next window size constraints using the specified size min
Definition: ImGui.cs:16433
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetAllocatorFunctions
static void igSetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc, void *userData)
Igs the set allocator functions using the specified alloc func
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSeparator
static void igSeparator()
Igs the separator
Alis.Core.Graphic.ImGui.ImGui.BeginPopup
static bool BeginPopup(string strId)
Describes whether begin popup
Definition: ImGui.cs:940
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSeparatorText
static void igSeparatorText(byte *label)
Igs the separator text using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginGroup
static void igBeginGroup()
Igs the begin group
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast, string format, ImGuiInputTextFlags flags)
Describes whether input scalar n
Definition: ImGui.cs:12344
Alis.Core.Graphic.ImGui.Structs.ImFont
The im font
Definition: ImFont.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSaveIniSettingsToMemory
static byte * igSaveIniSettingsToMemory(uint *outIniSize)
Igs the save ini settings to memory using the specified out ini size
Alis.Core.Graphic.ImGui.Enums.ImGuiDataType
ImGuiDataType
The im gui data type enum
Definition: ImGuiDataType.cs:36
Alis.Core.Graphic.ImGui.ImGui.TableSetBgColor
static void TableSetBgColor(ImGuiTableBgTarget target, uint color, int columnN)
Tables the set bg color using the specified target
Definition: ImGui.cs:20023
Alis.Core.Graphic.ImGui.ImGui.BeginDragDropSource
static bool BeginDragDropSource()
Describes whether begin drag drop source
Definition: ImGui.cs:718
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetColumnCount
static int igTableGetColumnCount()
Igs the table get column count
Alis.Core.Graphic.ImGui.ImGui.ListBox
static bool ListBox(string label, ref int currentItem, string[] items, int itemsCount)
Describes whether list box
Definition: ImGui.cs:13086
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreePush_Str
static void igTreePush_Str(byte *strId)
Igs the tree push str using the specified str id
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1)
Describes whether image button
Definition: ImGui.cs:9900
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowDockID
static void igSetNextWindowDockID(uint dockId, ImGuiCond cond)
Igs the set next window dock id using the specified dock id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetForegroundDrawList_ViewportPtr
static ImDrawList * igGetForegroundDrawList_ViewportPtr(ImGuiViewport *viewport)
Igs the get foreground draw list viewport ptr using the specified viewport
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igOpenPopup_Str
static void igOpenPopup_Str(byte *strId, ImGuiPopupFlags popupFlags)
Igs the open popup str using the specified str id
Alis.Core.Graphic.ImGui.Enums.ImGuiTableRowFlags
ImGuiTableRowFlags
The im gui table row flags enum
Definition: ImGuiTableRowFlags.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginTabBar
static byte igBeginTabBar(byte *strId, ImGuiTabBarFlags flags)
Igs the begin tab bar using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColumns
static void igColumns(int count, byte *id, byte border)
Igs the columns using the specified count
Alis.Core.Aspect.Math
Definition: ArgumentExceptionDestinationTooShort.cs:33
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igMenuItem_BoolPtr
static byte igMenuItem_BoolPtr(byte *label, byte *shortcut, byte *pSelected, byte enabled)
Igs the menu item bool ptr using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetItemRectMax
static void igGetItemRectMax(Vector2F *pOut)
Igs the get item rect max using the specified p out
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDebugTextEncoding
static void igDebugTextEncoding(byte *text)
Igs the debug text encoding using the specified text
Alis.Core.Graphic.ImGui.ImGui
The im gui class
Definition: ImGui.cs:45
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v)
Describes whether drag float
Definition: ImGui.cs:3494
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowPos
static void igGetWindowPos(Vector2F *pOut)
Igs the get window pos using the specified p out
Alis.Core.Graphic.ImGui.ImGui.BeginMainMenuBar
static bool BeginMainMenuBar()
Describes whether begin main menu bar
Definition: ImGui.cs:838
Alis.Core.Graphic.ImGui.ImGui.GetColumnWidth
static float GetColumnWidth()
Gets the column width
Definition: ImGui.cs:9038
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndListBox
static void igEndListBox()
Igs the end list box
Alis.Core.Graphic.ImGui.ImGui.TableSetColumnEnabled
static void TableSetColumnEnabled(int columnN, bool v)
Tables the set column enabled using the specified column n
Definition: ImGui.cs:20033
Alis.Core.Graphic.ImGui.ImGui.SetCurrentContext
static void SetCurrentContext(IntPtr ctx)
Sets the current context using the specified ctx
Definition: ImGui.cs:16041
Alis.Core.Graphic.ImGui.ImGui.GetStyle
static ImGuiStylePtr GetStyle()
Gets the style
Definition: ImGui.cs:9549
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsKeyReleased_Nil
static byte igIsKeyReleased_Nil(ImGuiKey key)
Igs the is key released nil using the specified key
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopupModal
static byte igBeginPopupModal(byte *name, byte *pOpen, ImGuiWindowFlags flags)
Igs the begin popup modal using the specified name
Alis.Core.Graphic.ImGui.ImGui.ProgressBar
static void ProgressBar(float fraction)
Progresses the bar using the specified fraction
Definition: ImGui.cs:15144
Alis.Core.Graphic.ImGui.Enums.ImGuiMouseButton
ImGuiMouseButton
The im gui mouse button enum
Definition: ImGuiMouseButton.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndDragDropTarget
static void igEndDragDropTarget()
Igs the end drag drop target
Alis.Core.Graphic.ImGui.Structs.ImFontAtlasPtr
The im font atlas ptr
Definition: ImFontAtlasPtr.cs:42
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format, string formatMax)
Describes whether drag int range 2
Definition: ImGui.cs:7816
Alis.Core.Graphic.ImGui.ImGui.CollapsingHeader
static bool CollapsingHeader(string label, ref bool pVisible, ImGuiTreeNodeFlags flags)
Describes whether collapsing header
Definition: ImGui.cs:2215
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1)
Images the user texture id
Definition: ImGui.cs:9766
Alis.Core.Graphic.ImGui.ImGui.SliderFloat2
static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax, string format, ImGuiSliderFlags flags)
Describes whether slider float 2
Definition: ImGui.cs:17890
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v)
Describes whether drag float 3
Definition: ImGui.cs:4334
Alis.Core.Graphic.ImGui.ImGui.SliderFloat
static bool SliderFloat(string label, ref float v, float vMin, float vMax, string format)
Describes whether slider float
Definition: ImGui.cs:17598
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed, int vMin)
Describes whether drag int
Definition: ImGui.cs:5897
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, uint v)
Values the prefix
Definition: ImGui.cs:20897
Alis.Core.Graphic.ImGui.ImGui.PushTextWrapPos
static void PushTextWrapPos()
Pushes the text wrap pos
Definition: ImGui.cs:15349
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopStyleVar
static void igPopStyleVar(int count)
Igs the pop style var using the specified count
Alis.Core.Graphic.ImGui.ImGui.BeginTable
static bool BeginTable(string strId, int column, ImGuiTableFlags flags, Vector2F outerSize, float innerWidth)
Describes whether begin table
Definition: ImGui.cs:1767
Alis.Core.Graphic.ImGui.Enums.ImGuiTableColumnFlags
ImGuiTableColumnFlags
The im gui table column flags enum
Definition: ImGuiTableColumnFlags.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreePop
static void igTreePop()
Igs the tree pop
Alis.Core.Graphic.ImGui.ImGui.InputTextMultiline
static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2F size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
Describes whether input text multiline
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputTextWithHint
static byte igInputTextWithHint(byte *label, byte *hint, byte *buf, uint bufSize, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void *userData)
Igs the input text with hint using the specified label
Alis.Core.Graphic.ImGui.ImGui.InputInt2
static bool InputInt2(string label, ref int v)
Describes whether input int 2
Definition: ImGui.cs:11560
Alis.Core.Aspect.Math.Vector.Vector2F
The vector
Definition: Vector2F.cs:45
Alis.Core.Graphic.ImGui.ImGui.PushStyleColor
static void PushStyleColor(ImGuiCol idx, uint col)
Pushes the style color using the specified idx
Definition: ImGui.cs:15301
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollFromPosX_Float
static void igSetScrollFromPosX_Float(float localX, float centerXRatio)
Igs the set scroll from pos x float using the specified local x
Alis.Core.Graphic.ImGui.Structs.ImGuiStylePtr
The im gui style ptr
Definition: ImGuiStylePtr.cs:41
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components)
Describes whether drag scalar n
Definition: ImGui.cs:8375
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSize
static void SetNextWindowSize(Vector2F size)
Sets the next window size using the specified size
Definition: ImGui.cs:16386
Alis.Core.Graphic.ImGui.Structs.ImGuiStylePtr.NativePtr
ImGuiStyle * NativePtr
Gets the value of the native ptr
Definition: ImGuiStylePtr.cs:45
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax, string format, ImGuiSliderFlags flags)
Describes whether slider angle
Definition: ImGui.cs:17458
Alis.Core.Aspect.Math.Vector.Vector3F
The vector
Definition: Vector3F.cs:45